claude-smart 0.2.45 → 0.2.46

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/tests/test_events_agent_end.py

@@ -0,0 +1,233 @@
+"""Tests for openclaw_smart.events.agent_end."""
+
+from __future__ import annotations
+
+import json
+from unittest.mock import patch
+
+import pytest
+from openclaw_smart import state
+from openclaw_smart.events import agent_end
+
+
+@pytest.fixture(autouse=True)
+def isolate_state_dir(monkeypatch, tmp_path):
+    sessions = tmp_path / "sessions"
+    monkeypatch.setenv("OPENCLAW_SMART_STATE_DIR", str(sessions))
+    return sessions
+
+
+def _read_records(sessions_dir, session_id="s1"):
+    path = sessions_dir / f"{session_id}.jsonl"
+    if not path.exists():
+        return []
+    return [json.loads(line) for line in path.read_text().splitlines() if line]
+
+
+def test_extract_assistant_text_plain_string():
+    text = agent_end._extract_assistant_text(
+        [
+            {"role": "user", "content": "hi"},
+            {"role": "assistant", "content": "hello"},
+        ]
+    )
+    assert text == "hello"
+
+
+def test_extract_assistant_text_block_form():
+    text = agent_end._extract_assistant_text(
+        [
+            {"role": "user", "content": "hi"},
+            {
+                "role": "assistant",
+                "content": [
+                    {"type": "text", "text": "first"},
+                    {"type": "text", "text": "second"},
+                ],
+            },
+        ]
+    )
+    assert "first" in text and "second" in text
+
+
+def test_extract_assistant_text_concatenates_trailing_assistant_turns():
+    text = agent_end._extract_assistant_text(
+        [
+            {"role": "user", "content": "q"},
+            {"role": "assistant", "content": "step 1"},
+            {"role": "assistant", "content": "step 2"},
+        ]
+    )
+    assert "step 1" in text
+    assert "step 2" in text
+
+
+def test_extract_assistant_text_stops_at_user_boundary():
+    text = agent_end._extract_assistant_text(
+        [
+            {"role": "assistant", "content": "old turn"},
+            {"role": "user", "content": "new q"},
+            {"role": "assistant", "content": "new answer"},
+        ]
+    )
+    assert "new answer" in text
+    assert "old turn" not in text
+
+
+def test_extract_assistant_text_handles_nested_message_shape():
+    """Accept Claude-Code-style ``{message: {role, content}}`` shape too."""
+    text = agent_end._extract_assistant_text(
+        [{"message": {"role": "assistant", "content": "hi"}}]
+    )
+    assert text == "hi"
+
+
+def test_extract_assistant_text_empty_for_no_messages():
+    assert agent_end._extract_assistant_text([]) == ""
+    assert agent_end._extract_assistant_text(None) == ""
+
+
+def test_handle_no_session_id_returns_silently(isolate_state_dir):
+    with patch("openclaw_smart.events.agent_end.publish") as pub:
+        agent_end.handle({})
+        pub.publish_unpublished.assert_not_called()
+
+
+def test_handle_appends_assistant_record(isolate_state_dir):
+    with (
+        patch("openclaw_smart.events.agent_end.publish") as pub,
+        patch(
+            "openclaw_smart.events.agent_end.ids.resolve_project_id_with_fallback",
+            return_value="proj-x",
+        ),
+    ):
+        pub.publish_unpublished.return_value = ("ok", 1)
+        agent_end.handle(
+            {
+                "sessionKey": "s1",
+                "agentId": "a",
+                "messages": [
+                    {"role": "user", "content": "q"},
+                    {"role": "assistant", "content": "Done."},
+                ],
+            }
+        )
+
+    records = _read_records(isolate_state_dir)
+    assert records[-1]["role"] == "Assistant"
+    assert records[-1]["content"] == "Done."
+    assert records[-1]["user_id"] == "proj-x"
+
+
+def test_handle_publishes_unpublished_slice(isolate_state_dir):
+    with (
+        patch("openclaw_smart.events.agent_end.publish") as pub,
+        patch(
+            "openclaw_smart.events.agent_end.ids.resolve_project_id_with_fallback",
+            return_value="proj-x",
+        ),
+    ):
+        pub.publish_unpublished.return_value = ("ok", 1)
+        agent_end.handle(
+            {
+                "sessionKey": "s1",
+                "messages": [{"role": "assistant", "content": "Done."}],
+            }
+        )
+        pub.publish_unpublished.assert_called_once()
+        kwargs = pub.publish_unpublished.call_args[1]
+        assert kwargs["session_id"] == "s1"
+        assert kwargs["project_id"] == "proj-x"
+        assert kwargs["force_extraction"] is False
+        assert kwargs["skip_aggregation"] is False
+
+
+def test_handle_resolves_citations(isolate_state_dir, monkeypatch):
+    # Seed the injected registry so cited tags resolve.
+    state.append_injected(
+        "s1",
+        [
+            {
+                "id": "s1-ab12",
+                "kind": "playbook",
+                "title": "Use OAuth2",
+                "real_id": "abc",
+            }
+        ],
+    )
+
+    with (
+        patch("openclaw_smart.events.agent_end.publish") as pub,
+        patch(
+            "openclaw_smart.events.agent_end.ids.resolve_project_id_with_fallback",
+            return_value="proj-x",
+        ),
+    ):
+        pub.publish_unpublished.return_value = ("ok", 1)
+        agent_end.handle(
+            {
+                "sessionKey": "s1",
+                "messages": [
+                    {
+                        "role": "assistant",
+                        "content": (
+                            "Implemented OAuth.\n"
+                            "✨ 1 openclaw-smart learning applied [oc:s1-ab12]"
+                        ),
+                    }
+                ],
+            }
+        )
+
+    records = _read_records(isolate_state_dir)
+    assert "cited_items" in records[-1]
+    cited = records[-1]["cited_items"]
+    assert cited[0]["id"] == "s1-ab12"
+    assert cited[0]["title"] == "Use OAuth2"
+    assert cited[0]["real_id"] == "abc"
+
+
+def test_handle_skips_unknown_citations(isolate_state_dir):
+    """Citations for ids not in the registry are dropped, not raised."""
+    with (
+        patch("openclaw_smart.events.agent_end.publish") as pub,
+        patch(
+            "openclaw_smart.events.agent_end.ids.resolve_project_id_with_fallback",
+            return_value="proj-x",
+        ),
+    ):
+        pub.publish_unpublished.return_value = ("ok", 1)
+        agent_end.handle(
+            {
+                "sessionKey": "s1",
+                "messages": [
+                    {
+                        "role": "assistant",
+                        "content": (
+                            "Done.\n✨ 1 openclaw-smart learning applied [oc:s9-9999]"
+                        ),
+                    }
+                ],
+            }
+        )
+    records = _read_records(isolate_state_dir)
+    assert "cited_items" not in records[-1]
+
+
+def test_handle_falls_back_to_session_id(isolate_state_dir):
+    with (
+        patch("openclaw_smart.events.agent_end.publish") as pub,
+        patch(
+            "openclaw_smart.events.agent_end.ids.resolve_project_id_with_fallback",
+            return_value="proj-x",
+        ),
+    ):
+        pub.publish_unpublished.return_value = ("ok", 1)
+        agent_end.handle(
+            {
+                "sessionId": "sess-y",
+                "messages": [{"role": "assistant", "content": "ok"}],
+            }
+        )
+        kwargs = pub.publish_unpublished.call_args[1]
+        assert kwargs["session_id"] == "sess-y"

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/tests/test_events_before_prompt_build.py

@@ -0,0 +1,116 @@
+"""Tests for openclaw_smart.events.before_prompt_build."""
+
+from __future__ import annotations
+
+import json
+from unittest.mock import patch
+
+import pytest
+from openclaw_smart.events import before_prompt_build as bpb
+
+
+@pytest.fixture(autouse=True)
+def isolate_state_dir(monkeypatch, tmp_path):
+    sessions = tmp_path / "sessions"
+    monkeypatch.setenv("OPENCLAW_SMART_STATE_DIR", str(sessions))
+    return sessions
+
+
+def test_handle_buffers_prompt(isolate_state_dir):
+    with (
+        patch("openclaw_smart.events.before_prompt_build.context_inject") as ci,
+        patch(
+            "openclaw_smart.events.before_prompt_build.ids.resolve_project_id_with_fallback",
+            return_value="proj-x",
+        ),
+    ):
+        ci.emit_context.return_value = False
+        bpb.handle(
+            {
+                "sessionKey": "s1",
+                "prompt": "implement OAuth",
+                "agentId": "agent-x",
+                "workspaceDir": "/tmp/x",
+            }
+        )
+
+    path = isolate_state_dir / "s1.jsonl"
+    assert path.exists()
+    lines = path.read_text().splitlines()
+    record = json.loads(lines[0])
+    assert record["role"] == "User"
+    assert record["content"] == "implement OAuth"
+    assert record["user_id"] == "proj-x"
+
+
+def test_handle_calls_emit_context_with_top_k():
+    with (
+        patch("openclaw_smart.events.before_prompt_build.context_inject") as ci,
+        patch(
+            "openclaw_smart.events.before_prompt_build.ids.resolve_project_id_with_fallback",
+            return_value="proj-x",
+        ),
+    ):
+        bpb.handle(
+            {
+                "sessionKey": "s1",
+                "prompt": "implement OAuth",
+                "agentId": "agent-x",
+                "workspaceDir": "/tmp/x",
+            }
+        )
+        ci.emit_context.assert_called_once()
+        kwargs = ci.emit_context.call_args[1]
+        assert kwargs["session_id"] == "s1"
+        assert kwargs["project_id"] == "proj-x"
+        assert kwargs["query"] == "implement OAuth"
+        assert kwargs["top_k"] == 3
+
+
+def test_handle_skips_when_no_session_id(isolate_state_dir):
+    with patch("openclaw_smart.events.before_prompt_build.context_inject") as ci:
+        bpb.handle({"prompt": "x", "agentId": "a"})
+        ci.emit_context.assert_not_called()
+    assert not isolate_state_dir.exists() or not any(isolate_state_dir.iterdir())
+
+
+def test_handle_skips_when_no_prompt(isolate_state_dir):
+    with patch("openclaw_smart.events.before_prompt_build.context_inject") as ci:
+        bpb.handle({"sessionKey": "s1", "prompt": "", "agentId": "a"})
+        ci.emit_context.assert_not_called()
+
+
+def test_handle_swallows_emit_exceptions(isolate_state_dir):
+    with (
+        patch("openclaw_smart.events.before_prompt_build.context_inject") as ci,
+        patch(
+            "openclaw_smart.events.before_prompt_build.ids.resolve_project_id_with_fallback",
+            return_value="proj-x",
+        ),
+    ):
+        ci.emit_context.side_effect = ConnectionError("reflexio down")
+        # Must not raise
+        bpb.handle(
+            {
+                "sessionKey": "s1",
+                "prompt": "implement OAuth",
+                "agentId": "a",
+                "workspaceDir": "/tmp/x",
+            }
+        )
+    # Prompt still buffered
+    path = isolate_state_dir / "s1.jsonl"
+    assert path.exists()
+
+
+def test_handle_falls_back_to_session_id():
+    with (
+        patch("openclaw_smart.events.before_prompt_build.context_inject") as ci,
+        patch(
+            "openclaw_smart.events.before_prompt_build.ids.resolve_project_id_with_fallback",
+            return_value="proj-x",
+        ),
+    ):
+        bpb.handle({"sessionId": "s2", "prompt": "hello", "agentId": "a"})
+        ci.emit_context.assert_called_once()
+        assert ci.emit_context.call_args[1]["session_id"] == "s2"

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/tests/test_events_before_tool_call.py

@@ -0,0 +1,35 @@
+"""Tests for openclaw_smart.events.before_tool_call (observe-only stub)."""
+
+from __future__ import annotations
+
+from openclaw_smart.events import before_tool_call as btc
+
+
+def test_handle_is_silent(capsys):
+    btc.handle(
+        {
+            "sessionKey": "s1",
+            "tool_name": "Edit",
+            "tool_input": {"file_path": "x.py", "new_string": "..."},
+            "agentId": "a",
+        }
+    )
+    assert capsys.readouterr().out == ""
+
+
+def test_handle_accepts_empty_payload(capsys):
+    btc.handle({})
+    assert capsys.readouterr().out == ""
+
+
+def test_handle_accepts_camelcase_payload(capsys):
+    """openClaw delivers camelCase fields; handler should ignore them silently."""
+    btc.handle(
+        {
+            "sessionKey": "s1",
+            "toolName": "Bash",
+            "params": {"command": "ls"},
+            "agentId": "a",
+        }
+    )
+    assert capsys.readouterr().out == ""

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/tests/test_events_session_end.py

@@ -0,0 +1,47 @@
+"""Tests for openclaw_smart.events.session_end."""
+
+from __future__ import annotations
+
+from unittest.mock import patch
+
+from openclaw_smart.events import session_end
+
+
+def test_handle_no_session_id_returns_silently():
+    with patch("openclaw_smart.events.session_end.publish") as pub:
+        session_end.handle({})
+        pub.publish_unpublished.assert_not_called()
+
+
+def test_handle_force_extracts():
+    with (
+        patch("openclaw_smart.events.session_end.publish") as pub,
+        patch(
+            "openclaw_smart.events.session_end.ids.resolve_project_id_with_fallback",
+            return_value="proj-x",
+        ),
+    ):
+        session_end.handle({"sessionKey": "s1", "agentId": "a"})
+        pub.publish_unpublished.assert_called_once()
+        kwargs = pub.publish_unpublished.call_args[1]
+        assert kwargs["session_id"] == "s1"
+        assert kwargs["project_id"] == "proj-x"
+        assert kwargs["force_extraction"] is True
+        assert kwargs["skip_aggregation"] is False
+
+
+def test_handle_falls_back_to_session_id_key():
+    with (
+        patch("openclaw_smart.events.session_end.publish") as pub,
+        patch(
+            "openclaw_smart.events.session_end.ids.resolve_project_id_with_fallback",
+            return_value="proj-y",
+        ),
+    ):
+        session_end.handle({"sessionId": "s2"})
+        pub.publish_unpublished.assert_called_once()
+        kwargs = pub.publish_unpublished.call_args[1]
+        assert kwargs["session_id"] == "s2"
+        assert kwargs["project_id"] == "proj-y"
+        assert kwargs["force_extraction"] is True
+        assert kwargs["skip_aggregation"] is False

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/tests/test_events_session_start.py

@@ -0,0 +1,109 @@
+"""Tests for openclaw_smart.events.session_start."""
+
+from __future__ import annotations
+
+import json
+from types import SimpleNamespace
+from unittest.mock import MagicMock, patch
+
+import pytest
+from openclaw_smart.events import session_start
+
+
+@pytest.fixture
+def fake_adapter():
+    adapter = MagicMock()
+    adapter.fetch_stall_state.return_value = None
+    adapter.apply_extraction_defaults.return_value = True
+    adapter.apply_optimizer_defaults.return_value = True
+    return adapter
+
+
+def test_handle_no_session_id_returns_silently(fake_adapter, capsys):
+    with patch.object(session_start, "_adapter", return_value=fake_adapter):
+        session_start.handle({})
+    assert capsys.readouterr().out == ""
+    fake_adapter.apply_extraction_defaults.assert_not_called()
+
+
+def test_handle_applies_extraction_defaults(fake_adapter, capsys):
+    with patch.object(session_start, "_adapter", return_value=fake_adapter):
+        session_start.handle({"sessionKey": "s1", "workspaceDir": "/tmp"})
+    fake_adapter.apply_extraction_defaults.assert_called_once_with(
+        window_size=5, stride_size=3
+    )
+
+
+def test_handle_applies_optimizer_defaults_by_default(fake_adapter, monkeypatch):
+    monkeypatch.delenv("OPENCLAW_SMART_ENABLE_OPTIMIZER", raising=False)
+    with patch.object(session_start, "_adapter", return_value=fake_adapter):
+        session_start.handle({"sessionKey": "s1"})
+    fake_adapter.apply_optimizer_defaults.assert_called_once()
+    kwargs = fake_adapter.apply_optimizer_defaults.call_args[1]
+    assert "openclaw-smart-optimizer-assistant" in kwargs["script_path"]
+
+
+def test_handle_skips_optimizer_when_disabled(fake_adapter, monkeypatch):
+    monkeypatch.setenv("OPENCLAW_SMART_ENABLE_OPTIMIZER", "0")
+    with patch.object(session_start, "_adapter", return_value=fake_adapter):
+        session_start.handle({"sessionKey": "s1"})
+    fake_adapter.apply_optimizer_defaults.assert_not_called()
+
+
+def test_handle_emits_banner_when_stall_active(fake_adapter, capsys):
+    fake_adapter.fetch_stall_state.return_value = SimpleNamespace(
+        stalled=True,
+        notified_in_cc=False,
+        reason="auth_error",
+        reset_estimate=None,
+    )
+    with patch.object(session_start, "_adapter", return_value=fake_adapter):
+        session_start.handle({"sessionKey": "s1"})
+    out = capsys.readouterr().out.strip()
+    assert out, "expected stdout envelope when stall is active"
+    parsed = json.loads(out)
+    assert "prependContext" in parsed
+    assert "openclaw-smart" in parsed["prependContext"]
+    fake_adapter.mark_stall_notified.assert_called_once()
+
+
+def test_handle_skips_banner_when_already_notified(fake_adapter, capsys):
+    fake_adapter.fetch_stall_state.return_value = SimpleNamespace(
+        stalled=True,
+        notified_in_cc=True,
+        reason="auth_error",
+        reset_estimate=None,
+    )
+    with patch.object(session_start, "_adapter", return_value=fake_adapter):
+        session_start.handle({"sessionKey": "s1"})
+    assert capsys.readouterr().out == ""
+    fake_adapter.mark_stall_notified.assert_not_called()
+
+
+def test_handle_skips_banner_when_not_stalled(fake_adapter, capsys):
+    fake_adapter.fetch_stall_state.return_value = SimpleNamespace(
+        stalled=False,
+        notified_in_cc=False,
+        reason=None,
+        reset_estimate=None,
+    )
+    with patch.object(session_start, "_adapter", return_value=fake_adapter):
+        session_start.handle({"sessionKey": "s1"})
+    assert capsys.readouterr().out == ""
+
+
+def test_handle_swallows_stall_state_exceptions(fake_adapter, capsys):
+    fake_adapter.fetch_stall_state.side_effect = RuntimeError("boom")
+    with patch.object(session_start, "_adapter", return_value=fake_adapter):
+        # Must not raise
+        session_start.handle({"sessionKey": "s1"})
+    assert capsys.readouterr().out == ""
+    # Defaults still applied
+    fake_adapter.apply_extraction_defaults.assert_called_once()
+
+
+def test_handle_falls_back_to_session_id_key(fake_adapter):
+    """If only ``sessionId`` is present (openClaw sometimes), it is used."""
+    with patch.object(session_start, "_adapter", return_value=fake_adapter):
+        session_start.handle({"sessionId": "sess-x"})
+    fake_adapter.apply_extraction_defaults.assert_called_once()

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/tests/test_hook_dispatch.py

@@ -0,0 +1,117 @@
+"""Tests for openclaw_smart.hook dispatch."""
+
+from __future__ import annotations
+
+import io
+import json
+
+import pytest
+from openclaw_smart import hook
+
+
+@pytest.fixture(autouse=True)
+def _reset_handlers():
+    """Reload handler dispatch dict for each test (state is module-global)."""
+    hook._HANDLERS = None
+    yield
+    hook._HANDLERS = None
+
+
+def test_main_dispatches_to_handler(monkeypatch):
+    called = {}
+
+    def fake_handler(payload):
+        called["payload"] = payload
+
+    monkeypatch.setattr(
+        "sys.stdin",
+        io.StringIO(json.dumps({"sessionKey": "s1", "agentId": "a"})),
+    )
+    monkeypatch.setattr(hook, "_HANDLERS", {"session-start": fake_handler})
+
+    rc = hook.main(["session-start"])
+    assert rc == 0
+    assert called["payload"] == {"sessionKey": "s1", "agentId": "a"}
+
+
+def test_main_accepts_host_arg(monkeypatch):
+    called = {}
+
+    def fake_handler(payload):
+        called["payload"] = payload
+
+    monkeypatch.setattr("sys.stdin", io.StringIO('{"sessionKey":"s1"}'))
+    monkeypatch.setattr(hook, "_HANDLERS", {"session-start": fake_handler})
+
+    rc = hook.main(["openclaw", "session-start"])
+    assert rc == 0
+    assert called
+
+
+def test_main_silent_when_recursion_guard_fires(monkeypatch, capsys):
+    monkeypatch.setenv("OPENCLAW_SMART_INTERNAL", "1")
+    monkeypatch.setattr("sys.stdin", io.StringIO("{}"))
+    called = {"count": 0}
+
+    def boom(payload):
+        called["count"] += 1
+        raise RuntimeError("should not be called")
+
+    monkeypatch.setattr(hook, "_HANDLERS", {"session-start": boom})
+    rc = hook.main(["session-start"])
+    assert rc == 0
+    assert called["count"] == 0
+    assert capsys.readouterr().out == ""
+
+
+def test_main_silent_on_handler_exception(monkeypatch, capsys):
+    monkeypatch.setattr("sys.stdin", io.StringIO("{}"))
+
+    def boom(payload):
+        raise RuntimeError("x")
+
+    monkeypatch.setattr(hook, "_HANDLERS", {"session-start": boom})
+    rc = hook.main(["session-start"])
+    assert rc == 0
+    assert capsys.readouterr().out == ""
+
+
+def test_main_silent_on_unknown_event(monkeypatch, capsys):
+    monkeypatch.setattr("sys.stdin", io.StringIO("{}"))
+    rc = hook.main(["no-such-event"])
+    assert rc == 0
+    assert capsys.readouterr().out == ""
+
+
+def test_main_silent_with_no_event(monkeypatch, capsys):
+    monkeypatch.setattr("sys.stdin", io.StringIO("{}"))
+    rc = hook.main([])
+    assert rc == 0
+    assert capsys.readouterr().out == ""
+
+
+def test_main_handles_malformed_stdin(monkeypatch):
+    called = {}
+
+    def fake_handler(payload):
+        called["payload"] = payload
+
+    monkeypatch.setattr("sys.stdin", io.StringIO("not json {{{"))
+    monkeypatch.setattr(hook, "_HANDLERS", {"session-start": fake_handler})
+    rc = hook.main(["session-start"])
+    assert rc == 0
+    # Malformed → empty dict, handler still called
+    assert called["payload"] == {}
+
+
+def test_load_handlers_includes_all_events():
+    handlers = hook._load_handlers()
+    expected = {
+        "session-start",
+        "before-prompt-build",
+        "before-tool-call",
+        "after-tool-call",
+        "agent-end",
+        "session-end",
+    }
+    assert set(handlers) == expected