coderouter-cli 2.3.0a3__tar.gz → 2.3.0a4__tar.gz

{coderouter_cli-2.3.0a3 → coderouter_cli-2.3.0a4}/CHANGELOG.md

@@ -6,6 +6,51 @@ versioning follows [SemVer](https://semver.org/).
 
 ---
 
+## [v2.3.0a4] — 2026-05-08 (Plugin SDK — ruff cleanup)
+
+Patch over `v2.3.0a3`. CI's `ruff check .` job surfaced six lint
+findings in the new Plugin SDK code. None affect runtime behavior.
+
+### Fixed
+
+- **RUF022**: `__all__` in `coderouter/plugins/__init__.py` is now
+  isort-sorted alphabetically.
+- **RUF006**: `_fanout_observers` was using `asyncio.create_task`
+  without holding a strong reference. Asyncio's task tracker only
+  keeps a weakref, so a fanout-in-flight task could be GC'd before
+  the observer ran. Fixed by storing tasks in a per-engine
+  ``_observer_tasks: set[asyncio.Task[None]]`` and removing each
+  via ``task.add_done_callback(set.discard)`` on completion. The
+  attribute is lazy-initialized in `_fanout_observers` itself so
+  engines built via ``__new__`` (which bypass ``__init__``) still
+  work.
+- **I001 + F841**: `tests/test_plugins_integration.py` had unused
+  imports (`AnthropicResponse`, `AnthropicUsage`) and an unused
+  local (`captured_chat`) left over from a build-engine helper
+  whose code path never ran. Removed the helper entirely; the
+  remaining tests exercise the engine's hook surface
+  (``_apply_input_filters`` / ``_fanout_observers`` /
+  ``_safe_observe``) directly, which is what they always actually
+  did.
+- **I001**: `tests/test_plugins_loader.py` import block reordered
+  alphabetically by module name.
+
+### Files touched
+
+```
+M  coderouter/plugins/__init__.py        — __all__ alphabetical
+M  coderouter/routing/fallback.py        — task strong-ref set
+M  tests/test_plugins_integration.py     — drop dead helper
+M  tests/test_plugins_loader.py          — import order
+M  tests/test_plugins_registry.py        — formatting nit (blank line)
+M  CHANGELOG.md, pyproject.toml          — 2.3.0a3 → 2.3.0a4
+```
+
+After this patch, ``ruff check .`` passes against every tracked
+Python file in the repo.
+
+---
+
 ## [v2.3.0a3] — 2026-05-08 (Plugin SDK — LogRecord.module collision fix)
 
 Patch over `v2.3.0a2`. The wheel-install-and-test job in CI surfaced

{coderouter_cli-2.3.0a3 → coderouter_cli-2.3.0a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coderouter-cli
-Version: 2.3.0a3
+Version: 2.3.0a4
 Summary: Local-first, free-first, fallback-built-in LLM router. Claude Code / OpenAI compatible.
 Project-URL: Homepage, https://github.com/zephel01/CodeRouter
 Project-URL: Repository, https://github.com/zephel01/CodeRouter

{coderouter_cli-2.3.0a3 → coderouter_cli-2.3.0a4}/coderouter/plugins/__init__.py

@@ -43,17 +43,14 @@ from coderouter.plugins.loader import (
 from coderouter.plugins.registry import PluginRegistry
 
 __all__ = [
-    # Active hooks
-    "InputFilter",
-    "Observer",
-    # Future hooks (Protocol-only, no engine integration yet)
+    "PLUGIN_GROUPS_FUTURE",
+    "PLUGIN_GROUPS_V2_3",
+    "Adapter",
     "Frontend",
     "Guard",
+    "InputFilter",
+    "Observer",
     "OutputFilter",
-    "Adapter",
-    # Discovery + container
     "PluginRegistry",
     "discover_and_load",
-    "PLUGIN_GROUPS_V2_3",
-    "PLUGIN_GROUPS_FUTURE",
 ]

{coderouter_cli-2.3.0a3 → coderouter_cli-2.3.0a4}/coderouter/routing/fallback.py

@@ -838,6 +838,12 @@ class FallbackEngine:
         # so tests that build the engine via ``FallbackEngine.__new__``
         # see an empty registry instead of AttributeError.
         self._plugin_registry: PluginRegistry = plugins or PluginRegistry.empty()
+        # v2.3.0: holds strong refs to in-flight Observer fanout tasks
+        # so the asyncio event loop's weak-ref bookkeeping doesn't GC
+        # them mid-flight (RUF006).  Tasks remove themselves on done
+        # via ``add_done_callback(_observer_tasks.discard)`` in
+        # :meth:`_fanout_observers`.
+        self._observer_tasks: set[asyncio.Task[None]] = set()
         # Cache adapters so we don't re-instantiate per request
         self._adapters: dict[str, BaseAdapter] = {
             p.name: build_adapter(p) for p in config.providers
@@ -1881,10 +1887,22 @@ class FallbackEngine:
         observers = self.plugins.observers
         if not observers:
             return
+        # Lazy-init the task set for engines built via ``__new__`` —
+        # mirrors the lazy ``plugins`` property pattern so legacy
+        # tests that bypass __init__ don't crash here.
+        if not hasattr(self, "_observer_tasks"):
+            self._observer_tasks = set()
         for obs in observers:
-            asyncio.create_task(
+            task = asyncio.create_task(
                 self._safe_observe(obs, event_type, payload)
             )
+            # Strong-ref keeps the task alive past the loop iteration;
+            # ``discard`` cleans up after the task completes (success
+            # or exception). Avoids the RUF006 footgun where
+            # asyncio.create_task's weakref-only bookkeeping can let
+            # the loop GC a fanout-in-progress task.
+            self._observer_tasks.add(task)
+            task.add_done_callback(self._observer_tasks.discard)
 
     async def _safe_observe(
         self,

{coderouter_cli-2.3.0a3 → coderouter_cli-2.3.0a4}/pyproject.toml

@@ -11,7 +11,7 @@
 # in plan.md §11.B; once granted, this name will become an alias and
 # `coderouter` will become the canonical distribution name.
 name = "coderouter-cli"
-version = "2.3.0a3"
+version = "2.3.0a4"
 description = "Local-first, free-first, fallback-built-in LLM router. Claude Code / OpenAI compatible."
 readme = "README.md"
 requires-python = ">=3.12"

{coderouter_cli-2.3.0a3 → coderouter_cli-2.3.0a4}/tests/test_plugins_integration.py

@@ -1,17 +1,14 @@
 """Integration tests: FallbackEngine + InputFilter / Observer hooks (v2.3.0).
 
-Exercises the actual hot path:
-
-- engine.generate_anthropic invokes registered InputFilters before
-  chain dispatch
-- a successful response triggers observer fanout with the
-  ``request_completed`` event
-- a failing filter is logged + skipped, the chain still runs
-- the no-plugin path is bit-identical to v2.2.0 (zero hook calls)
-
-Adapter calls are mocked at the dispatch level so we don't reach
-HTTPx — keeps the tests fast and offline.
+These exercise the engine-side helpers directly
+(``_apply_input_filters`` / ``_fanout_observers`` /
+``_safe_observe``). We don't actually invoke ``generate_anthropic`` /
+``stream_anthropic`` here because doing so would mean stubbing the
+entire HTTP / chain dispatch path; the helpers themselves carry the
+plugin contract, and the broader engine paths are covered by
+``test_fallback*.py``.
 """
+
 from __future__ import annotations
 
 import asyncio
@@ -22,13 +19,7 @@ import pytest
 from coderouter.config.schemas import CodeRouterConfig
 from coderouter.plugins.registry import PluginRegistry
 from coderouter.routing.fallback import FallbackEngine
-from coderouter.translation.anthropic import (
-    AnthropicMessage,
-    AnthropicRequest,
-    AnthropicResponse,
-    AnthropicUsage,
-)
-
+from coderouter.translation.anthropic import AnthropicMessage, AnthropicRequest
 
 # ---------------------------------------------------------------------
 # Synthetic plugin classes
@@ -78,101 +69,10 @@ class _RecordingObserver:
 
 
 # ---------------------------------------------------------------------
-# Fixtures + helpers
+# Helpers
 # ---------------------------------------------------------------------
 
 
-@pytest.fixture
-def fake_response() -> AnthropicResponse:
-    return AnthropicResponse(
-        id="msg_test",
-        type="message",
-        role="assistant",
-        content=[{"type": "text", "text": "ok"}],
-        model="x",
-        stop_reason="end_turn",
-        usage=AnthropicUsage(input_tokens=5, output_tokens=2),
-    )
-
-
-def _build_engine(
-    basic_config: CodeRouterConfig,
-    *,
-    plugins: PluginRegistry | None = None,
-    fake_response: AnthropicResponse | None = None,
-) -> tuple[FallbackEngine, list[AnthropicRequest]]:
-    """Build an engine and stub its first adapter to capture the
-    request and return ``fake_response``.
-
-    Returns ``(engine, captured_requests)`` — captured_requests is the
-    list of requests the (mocked) adapter saw, useful for asserting
-    that the InputFilter's mutation reached the dispatch layer.
-    """
-    engine = FallbackEngine(basic_config, plugins=plugins)
-    captured: list[AnthropicRequest] = []
-
-    # Stub: only used when test hands us a fake_response to return.
-    if fake_response is not None:
-        async def stub_generate_anthropic(
-            req: AnthropicRequest, *, overrides: Any = None
-        ) -> AnthropicResponse:
-            captured.append(req)
-            return fake_response
-
-        # Wrap the first adapter into a "native Anthropic" shape.
-        first_name = next(iter(engine._adapters))
-        first_adapter = engine._adapters[first_name]
-        # Convert the stub into AnthropicAdapter-shaped surface by
-        # patching the method directly. The engine's isinstance check
-        # for AnthropicAdapter still matters; instead of fighting it,
-        # we use a simpler approach: replace the chain resolution to
-        # always pick our stub adapter, AND patch generate_anthropic.
-        from coderouter.adapters.anthropic_native import AnthropicAdapter
-
-        if not isinstance(first_adapter, AnthropicAdapter):
-            # Not an Anthropic-native adapter — patch generate() and
-            # rely on the openai_compat code path which calls
-            # to_chat_request → adapter.generate() → to_anthropic_response.
-            async def stub_generate(
-                chat_req: Any, *, overrides: Any = None
-            ) -> Any:
-                # Build a minimal ChatResponse using the existing
-                # AnthropicResponse text. We import lazily to avoid a
-                # heavy module import at test collection time.
-                from coderouter.translation.convert import to_chat_request  # noqa: F401
-                from coderouter.translation import (  # noqa: F401
-                    ChatResponse,
-                    ChatResponseMessage,
-                )
-
-                # Capture the inbound chat request so we can also
-                # introspect what InputFilters mutated.
-                captured_chat = chat_req
-                # Build a chat-shaped response.
-                return ChatResponse(  # type: ignore[call-arg]
-                    id="cmpl_test",
-                    object="chat.completion",
-                    created=0,
-                    model=chat_req.model,
-                    choices=[
-                        {
-                            "index": 0,
-                            "message": {"role": "assistant", "content": "ok"},
-                            "finish_reason": "stop",
-                        }
-                    ],
-                    usage={"prompt_tokens": 5, "completion_tokens": 2, "total_tokens": 7},
-                )
-
-            first_adapter.generate = stub_generate  # type: ignore[method-assign]
-
-        # Always patch generate_anthropic regardless — if the adapter
-        # IS Anthropic-native this is the path; otherwise it's harmless.
-        first_adapter.generate_anthropic = stub_generate_anthropic  # type: ignore[method-assign,attr-defined]
-
-    return engine, captured
-
-
 def _make_request(text: str = "hi") -> AnthropicRequest:
     return AnthropicRequest(
         model="x",
@@ -188,15 +88,13 @@ def _make_request(text: str = "hi") -> AnthropicRequest:
 
 def test_no_plugins_means_no_hook_calls(basic_config: CodeRouterConfig) -> None:
     """With an empty registry, hook helpers are short-circuit no-ops."""
-    engine, _ = _build_engine(basic_config)
+    engine = FallbackEngine(basic_config)
 
-    # Direct private-method calls confirm zero work happens with no plugins.
+    # InputFilter chain returns request unchanged.
     out = asyncio.run(engine._apply_input_filters(_make_request()))
     assert out.messages[0].content == "hi"
 
-    # _fanout_observers with empty registry must NOT spawn tasks.
-    # Synchronous probe: just confirm it returns without error and
-    # doesn't iterate (no tasks pending afterwards).
+    # Observer fanout with empty registry must NOT spawn tasks.
     engine._fanout_observers("anything", request=None, response=None)
 
 
@@ -254,7 +152,6 @@ def test_safe_observe_swallows_exceptions(
     obs = BadObserver()
 
     with caplog.at_level("WARNING"):
-        # Direct call — the fanout wrapper does the same try/except.
         asyncio.run(engine._safe_observe(obs, "request_completed", {}))
 
     assert any(rec.msg == "observer-failed" for rec in caplog.records)
@@ -279,8 +176,6 @@ def test_observer_fanout_creates_tasks_when_observers_present(
         engine._fanout_observers("custom_event", payload_key="value")
         # Yield control so the spawned task gets a chance to run.
         await asyncio.sleep(0)
-        # Give the loop one more tick to ensure the fire-and-forget
-        # coroutine actually completes before we inspect.
         await asyncio.sleep(0)
 
     asyncio.run(run())

{coderouter_cli-2.3.0a3 → coderouter_cli-2.3.0a4}/tests/test_plugins_loader.py

@@ -11,6 +11,7 @@ while exercising the loader's real path: enabled-allowlist filtering,
 ``__init__`` dispatch with config dict, and degraded-continue on
 construction failure.
 """
+
 from __future__ import annotations
 
 import importlib.metadata as md
@@ -28,7 +29,6 @@ from coderouter.config.schemas import (
 from coderouter.plugins import loader as loader_mod
 from coderouter.plugins.loader import discover_and_load
 
-
 # ---------------------------------------------------------------------
 # Synthetic plugin classes — module-level so EntryPoint.load() can
 # resolve "tests.test_plugins_loader:..." strings via importlib.
@@ -187,9 +187,7 @@ def test_failing_init_does_not_abort_loader(
     )
     monkeypatch.setattr(loader_mod.md, "entry_points", fake_eps)
 
-    cfg = _make_config(
-        plugins_cfg=PluginsConfig(enabled=["bad-init", "good-filter"])
-    )
+    cfg = _make_config(plugins_cfg=PluginsConfig(enabled=["bad-init", "good-filter"]))
     with caplog.at_level("ERROR"):
         reg = discover_and_load(cfg)
 
@@ -256,6 +254,4 @@ def test_future_group_logs_warning_but_still_loads(
         reg = discover_and_load(cfg)
 
     assert reg.count("frontend") == 1
-    assert any(
-        rec.msg == "plugin-group-not-yet-active" for rec in caplog.records
-    )
+    assert any(rec.msg == "plugin-group-not-yet-active" for rec in caplog.records)

{coderouter_cli-2.3.0a3 → coderouter_cli-2.3.0a4}/tests/test_plugins_registry.py

@@ -1,4 +1,5 @@
 """Unit tests for ``coderouter.plugins.registry`` (v2.3.0)."""
+
 from __future__ import annotations
 
 from coderouter.plugins.registry import PluginRegistry