claude-smart 0.2.42 → 0.2.43

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

@@ -0,0 +1,76 @@
+"""Uvicorn log configuration for the Reflexio backend.
+
+This module exposes :data:`UVICORN_LOG_CONFIG`, a ``logging.config.dictConfig``
+dict that is handed to uvicorn at launch time (see
+:mod:`reflexio.server.__main__` and
+:func:`reflexio.cli.run_services.build_backend_service`).
+
+Why it lives here and not as an in-memory override:
+    Uvicorn's default formatter pads short level names so ``INFO`` aligns
+    with ``CRITICAL``. That alignment helps on a single-process console
+    but adds noise to our multiplexed ``[backend ]`` dev-server stream.
+    Rather than mutate uvicorn's already-configured loggers from inside
+    the app module (which is invisible and fragile), we tell uvicorn the
+    format upfront via its native ``log_config`` parameter. The dict
+    stays discoverable — users who want a different format can edit
+    this file or pass their own ``--log-config`` (the CLI flag wins).
+
+Downstream, :func:`reflexio.cli.log_format.highlight_log_level` colorises
+``ERROR:`` / ``WARNING:`` / ``CRITICAL:`` prefixes when stdout is a TTY,
+so this module deliberately stays color-neutral.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+# Plain level/message format — no ``%(levelprefix)s`` padding.
+LEVEL_FORMAT = "%(levelname)s: %(message)s"
+
+# Access-log fields mirror uvicorn's built-in AccessFormatter message shape,
+# minus the padded level prefix.
+ACCESS_FORMAT = '%(levelname)s: %(client_addr)s - "%(request_line)s" %(status_code)s'
+
+
+UVICORN_LOG_CONFIG: dict[str, Any] = {
+    "version": 1,
+    "disable_existing_loggers": False,
+    "formatters": {
+        # Access format references uvicorn-specific fields (client_addr,
+        # request_line, status_code) that only ``uvicorn.logging.AccessFormatter``
+        # knows how to populate from the log record's ``args`` tuple. The
+        # stdlib ``logging.Formatter`` raises ``KeyError: 'client_addr'`` on
+        # every request. Default formatter stays on stdlib because it uses
+        # only ``levelname`` / ``message``.
+        "default": {"format": LEVEL_FORMAT},
+        "access": {
+            "()": "uvicorn.logging.AccessFormatter",
+            "fmt": ACCESS_FORMAT,
+        },
+    },
+    "handlers": {
+        "default": {
+            "class": "logging.StreamHandler",
+            "formatter": "default",
+            "stream": "ext://sys.stderr",
+        },
+        "access": {
+            "class": "logging.StreamHandler",
+            "formatter": "access",
+            "stream": "ext://sys.stdout",
+        },
+    },
+    "loggers": {
+        "uvicorn": {
+            "handlers": ["default"],
+            "level": "INFO",
+            "propagate": False,
+        },
+        "uvicorn.error": {"level": "INFO"},
+        "uvicorn.access": {
+            "handlers": ["access"],
+            "level": "INFO",
+            "propagate": False,
+        },
+    },
+}

package/plugin/vendor/reflexio/reflexio/test_support/__init__.py

@@ -0,0 +1 @@
+"""Shared test infrastructure for reflexio OS and enterprise test suites."""

package/plugin/vendor/reflexio/reflexio/test_support/llm_fixtures.py

@@ -0,0 +1,62 @@
+"""Load recorded LLM response fixtures for replay-based tests.
+
+Fixture files live in ``tests/fixtures/llm/<name>.json`` and contain the
+full mock response structure matching ``litellm.completion`` output.
+
+Usage::
+
+    from reflexio.test_support.llm_fixtures import load_llm_fixture
+
+    def test_with_recorded_response(monkeypatch):
+        fixture = load_llm_fixture("profile_extraction")
+        monkeypatch.setattr("litellm.completion", lambda **kw: fixture)
+        # ... exercise code under test ...
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+from unittest.mock import MagicMock
+
+# reflexio/test_support/ -> repo root -> tests/fixtures/llm/
+_FIXTURE_DIR = Path(__file__).resolve().parents[2] / "tests" / "fixtures" / "llm"
+
+
+def load_llm_fixture(name: str) -> MagicMock:
+    """Load a recorded LLM response fixture and return it as a MagicMock.
+
+    Args:
+        name: Fixture name without extension (e.g. ``"profile_extraction"``).
+
+    Returns:
+        MagicMock mimicking a ``litellm.completion`` response.
+    """
+    fixture_path = _FIXTURE_DIR / f"{name}.json"
+    if not fixture_path.exists():
+        raise FileNotFoundError(f"LLM fixture '{name}' not found at {fixture_path}")
+    data: dict[str, Any] = json.loads(fixture_path.read_text())
+
+    choice = data["choices"][0]
+    mock = MagicMock()
+    mock.choices = [MagicMock()]
+    mock.choices[0].message.content = choice["message"]["content"]
+    mock.choices[0].finish_reason = choice.get("finish_reason", "stop")
+    return mock
+
+
+def load_llm_fixture_content(name: str) -> str:
+    """Load just the content string from a recorded LLM fixture.
+
+    Args:
+        name: Fixture name without extension.
+
+    Returns:
+        The raw content string from the fixture's first choice.
+    """
+    fixture_path = _FIXTURE_DIR / f"{name}.json"
+    if not fixture_path.exists():
+        raise FileNotFoundError(f"LLM fixture '{name}' not found at {fixture_path}")
+    data: dict[str, Any] = json.loads(fixture_path.read_text())
+    return data["choices"][0]["message"]["content"]

package/plugin/vendor/reflexio/reflexio/test_support/llm_mock.py

@@ -0,0 +1,242 @@
+"""Global LiteLLM mock for reflexio test suites.
+
+Patches ``litellm.completion`` with a deterministic mock that returns
+JSON responses based on prompt content heuristics. E2E tests are
+excluded from the session-level autouse so they can make real API
+calls — but an e2e test that wants determinism can opt in via the
+``patched_litellm`` context manager (or the matching ``mock_llm``
+pytest fixture wired into the e2e conftest).
+
+Response payloads are sourced from the model registry
+(``llm_model_registry.py``) so they always validate against the Pydantic
+models that services expect.
+
+Usage in conftest.py::
+
+    from reflexio.test_support.llm_mock import configure_llm_mock, cleanup_llm_mock
+
+    def pytest_configure(config):
+        configure_llm_mock(config)
+
+    def pytest_unconfigure(config):
+        cleanup_llm_mock(config)
+
+Opt-in usage in one e2e test::
+
+    from reflexio.test_support.llm_mock import patched_litellm
+
+    def test_something_e2e():
+        with patched_litellm():
+            ...  # litellm.completion is mocked for the duration
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import Iterator
+from contextlib import contextmanager
+from typing import Any
+from unittest.mock import MagicMock, patch
+
+from reflexio.test_support.llm_model_registry import get_model_registry
+
+
+def _create_mock_completion(
+    prompt_content: str, parse_structured_output: bool = False
+) -> MagicMock:
+    """Create a mock LiteLLM completion response.
+
+    Routes on prompt content heuristics; payloads come from the model
+    registry to guarantee schema validity.
+    """
+    registry = get_model_registry()
+
+    if "Output just a boolean value" in prompt_content:
+        content = str(registry["boolean_evaluation"].minimal_valid)
+    elif "policy consolidation" in prompt_content:
+        content = json.dumps(registry["playbook_aggregation"].minimal_valid)
+    elif (
+        "is_success to True" in prompt_content
+        and "is_escalated to True" in prompt_content
+    ):
+        # Anchor on two markers from the agent_success_evaluation prompt
+        # body — present in every variant of the success-eval prompt.
+        content = json.dumps(registry["agent_success_evaluation"].minimal_valid)
+    elif '"playbooks"' in prompt_content:
+        # Anchor on the schema marker every playbook-extraction prompt MUST
+        # describe (the JSON output key the LLM is told to return). This is
+        # intrinsic to the schema, not stylistic, so it survives prompt
+        # rewrites better than matching on a tagline like "policy mining".
+        content = json.dumps(registry["playbook_extraction"].minimal_valid)
+    elif parse_structured_output:
+        content = json.dumps(registry["profile_extraction"].minimal_valid)
+    else:
+        default_payload = json.dumps(registry["profile_update"].minimal_valid)
+        content = f"```json\n{default_payload}\n```"
+
+    mock_response = MagicMock()
+    mock_response.choices = [MagicMock()]
+    mock_response.choices[0].message.content = content
+    mock_response.choices[0].finish_reason = "stop"
+    return mock_response
+
+
+def _extraction_finish_args(prompt_content: str) -> dict[str, Any]:
+    """Pick the ``finish_extraction`` payload for an extraction tool-loop turn.
+
+    Profile and playbook extraction both run the always-on ``finish_extraction``
+    tool loop, so the mock must return the structured output as the *arguments*
+    of a ``finish_extraction`` tool call (not as message content). Routes on the
+    same schema marker the content-mode path uses.
+    """
+    registry = get_model_registry()
+    if '"playbooks"' in prompt_content:
+        return registry["playbook_extraction"].minimal_valid
+    return registry["profile_extraction"].minimal_valid
+
+
+def _mock_completion(*args: Any, **kwargs: Any) -> MagicMock:
+    """Mock implementation for litellm.completion."""
+    messages = kwargs.get("messages", args[0] if args else [])
+    prompt_content = ""
+    for message in messages:
+        if isinstance(message, dict) and "content" in message:
+            prompt_content += str(message["content"])
+
+    # Extraction now runs through the ``finish_extraction`` tool loop, which
+    # invokes ``litellm.completion`` with ``tools=``. In that mode the loop
+    # reads ``resp.tool_calls`` (not message content), so emit a single
+    # ``finish_extraction`` tool call carrying the structured output as args.
+    if kwargs.get("tools"):
+        # Imported lazily to avoid importing the extraction service stack at
+        # module load time (this module is imported by the root conftest).
+        from reflexio.server.services.extraction.resumable_agent import (
+            FINISH_EXTRACTION_TOOL_NAME,
+        )
+
+        return make_tool_call_response(
+            FINISH_EXTRACTION_TOOL_NAME, _extraction_finish_args(prompt_content)
+        )
+
+    parse_structured = kwargs.get("response_format") is not None
+    return _create_mock_completion(prompt_content, parse_structured)
+
+
+def _is_e2e_test_run(config: Any) -> bool:
+    """Check if this pytest run includes e2e tests.
+
+    Returns True if any of the test paths contain 'e2e_tests'.
+    """
+    args = config.args if hasattr(config, "args") else []
+    for arg in args:
+        if "e2e_tests" in str(arg):
+            return True
+
+    if hasattr(config, "workerinput"):
+        worker_args = config.workerinput.get("args", [])
+        for arg in worker_args:
+            if "e2e_tests" in str(arg):
+                return True
+
+    return False
+
+
+# Global patcher reference kept alive across the test session.
+_litellm_patcher = None
+
+
+def configure_llm_mock(config: Any) -> None:
+    """Call from ``pytest_configure`` to patch litellm for non-e2e tests."""
+    global _litellm_patcher  # noqa: PLW0603
+
+    if _is_e2e_test_run(config):
+        return
+
+    os.environ["MOCK_LLM_RESPONSE"] = "true"
+    _litellm_patcher = patch("litellm.completion", side_effect=_mock_completion)
+    _litellm_patcher.start()
+
+
+def cleanup_llm_mock(config: Any) -> None:  # noqa: ARG001
+    """Call from ``pytest_unconfigure`` to stop the patcher."""
+    global _litellm_patcher  # noqa: PLW0603
+
+    if _litellm_patcher:
+        _litellm_patcher.stop()
+        _litellm_patcher = None
+
+
+@contextmanager
+def patched_litellm() -> Iterator[None]:
+    """Opt-in patch for one e2e test that wants deterministic LLM responses.
+
+    The session-level ``configure_llm_mock`` skips e2e runs entirely so
+    historical e2e tests can hit real APIs. This context manager
+    re-enables the same mock for the scope of one test (or one block) —
+    useful for new e2e tests that need a predictable LLM response and
+    don't want to pay for or wait on a real provider.
+
+    Returns:
+        Iterator[None]: A context that patches ``litellm.completion``
+            on entry and restores the original on exit.
+    """
+    os.environ["MOCK_LLM_RESPONSE"] = "true"
+    patcher = patch("litellm.completion", side_effect=_mock_completion)
+    patcher.start()
+    try:
+        yield
+    finally:
+        patcher.stop()
+        # Leave MOCK_LLM_RESPONSE as-is — tests that read it should not
+        # depend on its lifetime being tied to a single context block.
+
+
+def make_tool_call_response(tool_name: str, args: dict[str, Any]) -> MagicMock:
+    """Build a litellm ModelResponse-shaped mock with a single tool_call.
+
+    Used by unit tests that drive tool loops against the patched
+    ``litellm.completion``. Not routed automatically by prompt
+    heuristics — callers install it explicitly with ``side_effect``.
+
+    Args:
+        tool_name (str): The name the assistant is calling.
+        args (dict[str, Any]): JSON-serialisable arguments passed to the tool.
+
+    Returns:
+        MagicMock: A response object shaped like a litellm ModelResponse
+            whose first choice has ``finish_reason="tool_calls"`` and a
+            single tool call matching the given name and args.
+    """
+    resp = MagicMock()
+    resp.choices = [MagicMock()]
+    resp.choices[0].finish_reason = "tool_calls"
+    resp.choices[0].message.content = None
+    tc = MagicMock()
+    tc.id = f"tc_{tool_name}"
+    tc.type = "function"
+    tc.function.name = tool_name
+    tc.function.arguments = json.dumps(args)
+    resp.choices[0].message.tool_calls = [tc]
+    return resp
+
+
+def make_finish_response(text: str = "done") -> MagicMock:
+    """Build a normal (non-tool-call) assistant message.
+
+    Used to terminate a tool loop that was driven by repeated
+    ``make_tool_call_response`` mocks.
+
+    Args:
+        text (str): Content of the terminal message.
+
+    Returns:
+        MagicMock: A response object with ``finish_reason="stop"``,
+            the given text, and ``tool_calls=None``.
+    """
+    resp = MagicMock()
+    resp.choices = [MagicMock()]
+    resp.choices[0].finish_reason = "stop"
+    resp.choices[0].message.content = text
+    resp.choices[0].message.tool_calls = None
+    return resp

package/plugin/vendor/reflexio/reflexio/test_support/llm_model_registry.py

@@ -0,0 +1,129 @@
+"""Registry mapping LLM operations to their expected Pydantic output models.
+
+Each entry pairs a descriptive key with the Pydantic model class the service
+expects and a minimal valid JSON instance that ``model_validate()`` must accept.
+This serves as the single source of truth for mock response shapes, used by
+both the heuristic mock (``llm_mock.py``) and schema compliance tests.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from pydantic import BaseModel
+
+
+@dataclass(frozen=True)
+class ModelRegistryEntry:
+    """A registry entry pairing a Pydantic model with a minimal valid instance.
+
+    Args:
+        model_class: The Pydantic model class, or None for raw string responses.
+        minimal_valid: A dict (or raw value) that ``model_class.model_validate()`` accepts.
+    """
+
+    model_class: type[BaseModel] | None
+    minimal_valid: dict[str, Any] | str
+
+
+def _build_registry() -> dict[str, ModelRegistryEntry]:
+    """Build the model registry with lazy imports to avoid circular dependencies."""
+    from reflexio.server.services.agent_success_evaluation.agent_success_evaluation_constants import (
+        AgentSuccessEvaluationOutput,
+    )
+    from reflexio.server.services.playbook.playbook_consolidator import (
+        PlaybookConsolidationOutput,
+    )
+    from reflexio.server.services.playbook.playbook_service_utils import (
+        PlaybookAggregationOutput,
+        StructuredPlaybookList,
+    )
+    from reflexio.server.services.profile.profile_deduplicator import (
+        ProfileDeduplicationOutput,
+    )
+    from reflexio.server.services.profile.profile_generation_service_utils import (
+        ProfileUpdateOutput,
+        StructuredProfilesOutput,
+    )
+
+    return {
+        "playbook_extraction": ModelRegistryEntry(
+            model_class=StructuredPlaybookList,
+            minimal_valid={
+                "playbooks": [
+                    {
+                        "content": "When user asks a question, provide a detailed answer rather than a brief response.",
+                        "trigger": "when user asks a question",
+                    },
+                ],
+            },
+        ),
+        "playbook_aggregation": ModelRegistryEntry(
+            model_class=PlaybookAggregationOutput,
+            minimal_valid={
+                "playbook": {
+                    "content": "When user asks about implementation, provide step-by-step explanations rather than high-level overviews.",
+                    "trigger": "when user asks about implementation",
+                },
+            },
+        ),
+        "playbook_consolidation": ModelRegistryEntry(
+            model_class=PlaybookConsolidationOutput,
+            minimal_valid={
+                "decisions": [
+                    {"kind": "independent", "new_id": "NEW-0"},
+                ],
+            },
+        ),
+        "profile_extraction": ModelRegistryEntry(
+            model_class=StructuredProfilesOutput,
+            minimal_valid={
+                "profiles": [
+                    {"content": "likes sushi", "time_to_live": "one_month"},
+                ],
+            },
+        ),
+        "profile_update": ModelRegistryEntry(
+            model_class=ProfileUpdateOutput,
+            minimal_valid={
+                "add": [
+                    {"content": "prefers dark mode", "time_to_live": "one_month"},
+                ],
+                "delete": [],
+                "mention": [],
+            },
+        ),
+        "profile_deduplication": ModelRegistryEntry(
+            model_class=ProfileDeduplicationOutput,
+            minimal_valid={
+                "duplicate_groups": [],
+                "unique_ids": ["NEW-0"],
+            },
+        ),
+        "agent_success_evaluation": ModelRegistryEntry(
+            model_class=AgentSuccessEvaluationOutput,
+            minimal_valid={
+                "is_success": True,
+                "is_escalated": False,
+            },
+        ),
+        # F1 cleanup: ``agent_success_evaluation_comparison`` was removed along
+        # with the session-level shadow comparison branch. Per-turn shadow
+        # comparison registers its own registry entry alongside its prompt.
+        "boolean_evaluation": ModelRegistryEntry(
+            model_class=None,
+            minimal_valid="true",
+        ),
+    }
+
+
+_REGISTRY: dict[str, ModelRegistryEntry] | None = None
+
+
+def get_model_registry() -> dict[str, ModelRegistryEntry]:
+    """Return the model registry, building it on first access."""
+    global _REGISTRY  # noqa: PLW0603
+    if _REGISTRY is None:
+        _REGISTRY = _build_registry()
+    return _REGISTRY

package/plugin/vendor/reflexio/reflexio/test_support/skip_decorators.py

@@ -0,0 +1,43 @@
+"""Test skip decorators shared between OS and enterprise test suites."""
+
+from __future__ import annotations
+
+import base64
+import os
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+
+def skip_in_precommit(func: Callable[..., Any]) -> Callable[..., Any]:
+    """Decorator to skip tests during pre-commit hooks."""
+    return pytest.mark.skipif(
+        os.environ.get("PRECOMMIT") == "1", reason="Test skipped in pre-commit hook"
+    )(func)
+
+
+def skip_low_priority(func: Callable[..., Any]) -> Callable[..., Any]:
+    """Decorator to skip low priority tests unless explicitly requested.
+
+    These tests are skipped by default and only run when RUN_LOW_PRIORITY=1 is set.
+
+    Usage::
+
+        @skip_low_priority
+        def test_something_low_priority():
+            ...
+
+    To run low priority tests::
+
+        RUN_LOW_PRIORITY=1 pytest ...
+    """
+    return pytest.mark.skipif(
+        os.environ.get("RUN_LOW_PRIORITY") != "1",
+        reason="Low priority test - set RUN_LOW_PRIORITY=1 to run",
+    )(func)
+
+
+def encode_image_to_base64(image_fp: str) -> str:
+    return base64.b64encode(Path(image_fp).read_bytes()).decode("utf-8")