claude-smart 0.2.45 → 0.2.46

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

@@ -0,0 +1,41 @@
+"""Tests for openclaw_smart.ids."""
+
+from __future__ import annotations
+
+from unittest.mock import patch
+
+from openclaw_smart import ids
+
+
+def test_resolve_project_id_uses_git_toplevel(tmp_path):
+    with patch("openclaw_smart.ids._resolve_from_git", return_value="my-repo"):
+        assert ids.resolve_project_id(str(tmp_path)) == "my-repo"
+
+
+def test_resolve_project_id_falls_back_to_cwd_basename(tmp_path):
+    with patch("openclaw_smart.ids._resolve_from_git", return_value=None):
+        assert ids.resolve_project_id(str(tmp_path)) == tmp_path.name
+
+
+def test_resolve_project_id_with_fallback_uses_git(tmp_path):
+    with patch("openclaw_smart.ids._resolve_from_git", return_value="my-repo"):
+        assert (
+            ids.resolve_project_id_with_fallback(str(tmp_path), "agent-x") == "my-repo"
+        )
+
+
+def test_resolve_project_id_with_fallback_uses_agent_id(tmp_path):
+    with patch("openclaw_smart.ids._resolve_from_git", return_value=None):
+        assert (
+            ids.resolve_project_id_with_fallback(str(tmp_path), "agent-x") == "agent-x"
+        )
+
+
+def test_resolve_project_id_with_fallback_uses_literal(tmp_path):
+    with patch("openclaw_smart.ids._resolve_from_git", return_value=None):
+        assert ids.resolve_project_id_with_fallback(str(tmp_path), None) == "openclaw"
+
+
+def test_resolve_project_id_with_fallback_empty_agent_id_uses_literal(tmp_path):
+    with patch("openclaw_smart.ids._resolve_from_git", return_value=None):
+        assert ids.resolve_project_id_with_fallback(str(tmp_path), "") == "openclaw"

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

@@ -0,0 +1,50 @@
+"""Tests for openclaw_smart.internal_call."""
+
+from __future__ import annotations
+
+from openclaw_smart import internal_call
+
+
+def test_guard_fires_when_env_set(monkeypatch):
+    monkeypatch.setenv("OPENCLAW_SMART_INTERNAL", "1")
+    assert internal_call.is_internal_invocation({}) is True
+
+
+def test_guard_inactive_by_default(monkeypatch):
+    monkeypatch.delenv("OPENCLAW_SMART_INTERNAL", raising=False)
+    assert internal_call.is_internal_invocation({}) is False
+
+
+def test_guard_fires_when_cwd_inside_reflexio(monkeypatch, tmp_path):
+    monkeypatch.delenv("OPENCLAW_SMART_INTERNAL", raising=False)
+    repo = tmp_path / "reflexio-repo"
+    inner = repo / "src" / "module"
+    inner.mkdir(parents=True)
+    monkeypatch.setattr(internal_call, "_REFLEXIO_DIR", repo.resolve())
+    assert internal_call.is_internal_invocation({"cwd": str(inner)}) is True
+
+
+def test_guard_inactive_when_cwd_outside_reflexio(monkeypatch, tmp_path):
+    monkeypatch.delenv("OPENCLAW_SMART_INTERNAL", raising=False)
+    repo = tmp_path / "reflexio-repo"
+    other = tmp_path / "other"
+    repo.mkdir()
+    other.mkdir()
+    monkeypatch.setattr(internal_call, "_REFLEXIO_DIR", repo.resolve())
+    assert internal_call.is_internal_invocation({"cwd": str(other)}) is False
+
+
+def test_guard_handles_workspace_dir_key(monkeypatch, tmp_path):
+    """openClaw payloads use ``workspaceDir`` rather than ``cwd``."""
+    monkeypatch.delenv("OPENCLAW_SMART_INTERNAL", raising=False)
+    repo = tmp_path / "reflexio-repo"
+    inner = repo / "src"
+    inner.mkdir(parents=True)
+    monkeypatch.setattr(internal_call, "_REFLEXIO_DIR", repo.resolve())
+    assert internal_call.is_internal_invocation({"workspaceDir": str(inner)}) is True
+
+
+def test_guard_inactive_when_cwd_missing(monkeypatch):
+    monkeypatch.delenv("OPENCLAW_SMART_INTERNAL", raising=False)
+    assert internal_call.is_internal_invocation({"cwd": ""}) is False
+    assert internal_call.is_internal_invocation({"cwd": None}) is False

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

@@ -0,0 +1,88 @@
+"""Tests for openclaw_smart.oc_cite."""
+
+from __future__ import annotations
+
+from openclaw_smart import oc_cite
+
+
+def test_rank_id_skill_with_fingerprint():
+    tag = oc_cite.rank_id("playbook", 1, "abc12345")
+    assert tag == "s1-abc1"
+
+
+def test_rank_id_preference_with_fingerprint():
+    tag = oc_cite.rank_id("profile", 2, "DEAD-beef-1234")
+    assert tag == "p2-dead"
+
+
+def test_rank_id_without_real_id_omits_fingerprint():
+    assert oc_cite.rank_id("playbook", 3) == "s3"
+    assert oc_cite.rank_id("profile", 4) == "p4"
+
+
+def test_rank_id_with_non_alnum_real_id():
+    assert oc_cite.rank_id("playbook", 1, "---") == "s1"
+
+
+def test_rank_id_rejects_unknown_kind():
+    import pytest
+
+    with pytest.raises(ValueError):
+        oc_cite.rank_id("something-else", 1)
+
+
+def test_parse_citation_command_extracts_ids():
+    cmd = "oc-cite s1-ab12 p2-cd34"
+    assert oc_cite.parse_citation_command(cmd) == ["s1-ab12", "p2-cd34"]
+
+
+def test_parse_citation_command_accepts_prefix():
+    assert oc_cite.parse_citation_command("oc-cite oc:s1-ab12") == ["s1-ab12"]
+
+
+def test_parse_citation_command_rejects_chained_commands():
+    assert oc_cite.parse_citation_command("oc-cite s1 && echo x") == []
+
+
+def test_parse_citation_command_rejects_path_with_args():
+    # Path-prefixed binary is fine; extra trailing junk is not.
+    assert oc_cite.parse_citation_command("/usr/bin/oc-cite s1-ab12") == ["s1-ab12"]
+    assert oc_cite.parse_citation_command("oc-cite s1 garbage extra") == []
+
+
+def test_parse_text_citations_single():
+    text = "Answer body...\n✨ 1 openclaw-smart learning applied [oc:s1-ab12]"
+    assert oc_cite.parse_text_citations(text) == ["s1-ab12"]
+
+
+def test_parse_text_citations_multi():
+    text = "Done.\n✨ 2 openclaw-smart learnings applied [oc:s1-ab12,p2-cd34]"
+    assert oc_cite.parse_text_citations(text) == ["s1-ab12", "p2-cd34"]
+
+
+def test_parse_text_citations_no_marker_returns_empty():
+    text = "Body that mentions [oc:s1-ab12] but no marker line."
+    assert oc_cite.parse_text_citations(text) == []
+
+
+def test_parse_text_citations_last_wins():
+    text = (
+        "✨ 1 openclaw-smart learning applied [oc:s1-aaaa]\n"
+        "more text\n"
+        "✨ 1 openclaw-smart learning applied [oc:s2-bbbb]"
+    )
+    assert oc_cite.parse_text_citations(text) == ["s2-bbbb"]
+
+
+def test_citation_instruction_uses_oc_prefix():
+    assert "[oc:" in oc_cite.CITATION_INSTRUCTION
+    assert "[cs:" not in oc_cite.CITATION_INSTRUCTION
+    assert "openclaw-smart" in oc_cite.CITATION_INSTRUCTION
+
+
+def test_ensure_installed_returns_install_path(monkeypatch, tmp_path):
+    monkeypatch.setattr(oc_cite, "_INSTALL_DIR", tmp_path / "bin")
+    monkeypatch.setattr(oc_cite, "INSTALL_PATH", tmp_path / "bin" / "oc-cite")
+    # Source script likely doesn't exist yet — should still return target path.
+    result = oc_cite.ensure_installed()
+    assert result == tmp_path / "bin" / "oc-cite"

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

@@ -0,0 +1,48 @@
+"""Tests for openclaw_smart.publish."""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+from openclaw_smart import publish, state
+
+
+@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
+
+
+class _Adapter:
+    def __init__(self) -> None:
+        self.calls = 0
+
+    def publish(self, **_kwargs) -> bool:  # noqa: ANN003
+        self.calls += 1
+        return True
+
+
+def test_publish_unpublished_serializes_with_lock_and_stamps_watermark(
+    isolate_state_dir,
+):
+    state.append("s1", {"role": "User", "content": "hi"})
+    adapter = _Adapter()
+
+    status, count = publish.publish_unpublished(
+        session_id="s1",
+        project_id="proj",
+        force_extraction=False,
+        skip_aggregation=False,
+        adapter=adapter,
+    )
+
+    assert (status, count) == ("ok", 1)
+    assert adapter.calls == 1
+    assert (isolate_state_dir / "s1.publish.lock").exists()
+    records = [
+        json.loads(line)
+        for line in (isolate_state_dir / "s1.jsonl").read_text().splitlines()
+    ]
+    assert records[-1] == {"published_up_to": 1}

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

@@ -0,0 +1,48 @@
+"""Tests for openclaw_smart.query_compose."""
+
+from __future__ import annotations
+
+from openclaw_smart import query_compose
+
+
+def test_edit_tool_query_uses_basename_and_snippet():
+    q = query_compose.from_tool_call(
+        "Edit", {"file_path": "src/auth.py", "new_string": "import oauth2"}
+    )
+    assert "auth.py" in q
+    assert "import oauth2" in q
+    # Full directory path is dropped — only basename survives.
+    assert "src/" not in q
+
+
+def test_write_tool_uses_content_fallback():
+    q = query_compose.from_tool_call(
+        "Write", {"file_path": "notes.md", "content": "release plan"}
+    )
+    assert "notes.md" in q
+    assert "release plan" in q
+
+
+def test_bash_tool_query_uses_first_line():
+    q = query_compose.from_tool_call("Bash", {"command": "pytest tests/\nexit 0"})
+    assert "pytest tests/" in q
+    assert "exit 0" not in q
+
+
+def test_empty_input_returns_empty_for_known_tool():
+    assert query_compose.from_tool_call("Edit", {}) == ""
+    assert query_compose.from_tool_call("Bash", {}) == ""
+
+
+def test_unknown_tool_returns_empty():
+    assert query_compose.from_tool_call("UnknownTool", {"foo": "bar"}) == ""
+
+
+def test_long_snippet_is_truncated():
+    long_text = "a" * 1000
+    q = query_compose.from_tool_call(
+        "Edit", {"file_path": "x.py", "new_string": long_text}
+    )
+    # Basename + space + snippet truncated to 400 chars
+    assert "a" * 400 in q
+    assert len(q) <= len("x.py ") + 400

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

@@ -0,0 +1,188 @@
+"""Tests for openclaw_smart.reflexio_adapter."""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+from openclaw_smart.reflexio_adapter import Adapter
+
+
+def test_default_url_is_8071():
+    # 8071/8072 matches claude-smart so the two plugins share one local
+    # reflexio backend; 8061 is reserved for a developer's own instance.
+    adapter = Adapter()
+    assert adapter.url == "http://localhost:8071/"
+
+
+def test_env_var_overrides_url(monkeypatch):
+    monkeypatch.setenv("REFLEXIO_URL", "http://example.com:9000/")
+    adapter = Adapter()
+    assert adapter.url == "http://example.com:9000/"
+
+
+def test_explicit_url_wins_over_env(monkeypatch):
+    monkeypatch.setenv("REFLEXIO_URL", "http://example.com:9000/")
+    adapter = Adapter(url="http://other:7000/")
+    assert adapter.url == "http://other:7000/"
+
+
+def test_get_client_returns_none_on_construction_failure():
+    adapter = Adapter()
+    with patch(
+        "openclaw_smart.reflexio_adapter.ReflexioClient",
+        side_effect=ConnectionError,
+        create=True,
+    ):
+        # ReflexioClient is imported lazily inside _get_client; we patch on
+        # the imported module to mimic that path.
+        pass
+    with patch.dict(
+        "sys.modules",
+        {"reflexio": MagicMock(ReflexioClient=MagicMock(side_effect=ConnectionError))},
+    ):
+        assert adapter._get_client() is None
+
+
+def test_publish_returns_true_for_empty_interactions():
+    adapter = Adapter()
+    assert adapter.publish(session_id="s", project_id="p", interactions=[]) is True
+
+
+def test_publish_returns_false_when_client_none():
+    adapter = Adapter()
+    with patch.object(adapter, "_get_client", return_value=None):
+        assert (
+            adapter.publish(
+                session_id="s",
+                project_id="p",
+                interactions=[{"role": "User", "content": "x"}],
+            )
+            is False
+        )
+
+
+def test_publish_passes_openclaw_agent_version():
+    fake_client = MagicMock()
+    adapter = Adapter()
+    with patch.object(adapter, "_get_client", return_value=fake_client):
+        adapter.publish(
+            session_id="s1",
+            project_id="proj",
+            interactions=[{"role": "User", "content": "x"}],
+        )
+        kwargs = fake_client.publish_interaction.call_args[1]
+        assert kwargs["agent_version"] == "openclaw"
+        assert kwargs["user_id"] == "proj"
+        assert kwargs["session_id"] == "s1"
+        assert kwargs["wait_for_response"] is False
+
+
+def test_publish_forwards_force_extraction():
+    fake_client = MagicMock()
+    adapter = Adapter()
+    with patch.object(adapter, "_get_client", return_value=fake_client):
+        adapter.publish(
+            session_id="s1",
+            project_id="p",
+            interactions=[{"role": "User"}],
+            force_extraction=True,
+            skip_aggregation=True,
+        )
+        kwargs = fake_client.publish_interaction.call_args[1]
+        assert kwargs["force_extraction"] is True
+        assert kwargs["skip_aggregation"] is True
+
+
+def test_publish_returns_false_on_exception():
+    fake_client = MagicMock()
+    fake_client.publish_interaction.side_effect = RuntimeError("boom")
+    adapter = Adapter()
+    with patch.object(adapter, "_get_client", return_value=fake_client):
+        assert (
+            adapter.publish(
+                session_id="s",
+                project_id="p",
+                interactions=[{"role": "User"}],
+            )
+            is False
+        )
+
+
+def test_search_all_degrades_to_empty():
+    adapter = Adapter()
+    with patch.object(adapter, "_get_client", return_value=None):
+        u, a, p = adapter.search_all(project_id="p", query="q", top_k=3)
+        assert u == [] and a == [] and p == []
+
+
+def test_search_all_passes_agent_version():
+    fake_client = MagicMock()
+    fake_client.search.return_value = MagicMock(
+        user_playbooks=[], agent_playbooks=[], profiles=[]
+    )
+    adapter = Adapter()
+    with patch.object(adapter, "_get_client", return_value=fake_client):
+        adapter.search_all(project_id="p", query="q", top_k=5)
+        kwargs = fake_client.search.call_args[1]
+        assert kwargs["agent_version"] == "openclaw"
+        assert kwargs["user_id"] == "p"
+
+
+def test_fetch_user_playbooks_degrades_to_empty():
+    adapter = Adapter()
+    with patch.object(adapter, "_get_client", return_value=None):
+        assert adapter.fetch_user_playbooks(project_id="p") == []
+
+
+def test_fetch_agent_playbooks_filters_rejected():
+    fake_client = MagicMock()
+    fake_client.search_agent_playbooks.return_value = MagicMock(
+        agent_playbooks=[
+            {"id": "a", "playbook_status": "approved"},
+            {"id": "b", "playbook_status": "rejected"},
+            {"id": "c", "playbook_status": "pending"},
+        ]
+    )
+    adapter = Adapter()
+    with patch.object(adapter, "_get_client", return_value=fake_client):
+        result = adapter.fetch_agent_playbooks(top_k=5)
+        ids = [item["id"] for item in result]
+        assert "b" not in ids
+        assert "a" in ids and "c" in ids
+
+
+def test_apply_extraction_defaults_skips_when_already_matching():
+    fake_client = MagicMock()
+    config = MagicMock(window_size=10, stride_size=5)
+    fake_client.get_config.return_value = config
+    adapter = Adapter()
+    with patch.object(adapter, "_get_client", return_value=fake_client):
+        assert adapter.apply_extraction_defaults(window_size=10, stride_size=5) is True
+        fake_client.set_config.assert_not_called()
+
+
+def test_apply_extraction_defaults_writes_when_different():
+    fake_client = MagicMock()
+    config = MagicMock(window_size=99, stride_size=99)
+    fake_client.get_config.return_value = config
+    adapter = Adapter()
+    with patch.object(adapter, "_get_client", return_value=fake_client):
+        adapter.apply_extraction_defaults(window_size=10, stride_size=5)
+        assert config.window_size == 10
+        assert config.stride_size == 5
+        fake_client.set_config.assert_called_once_with(config)
+
+
+def test_fetch_stall_state_returns_none_when_client_none():
+    adapter = Adapter()
+    with patch.object(adapter, "_get_client", return_value=None):
+        assert adapter.fetch_stall_state() is None
+
+
+def test_mark_stall_notified_swallows_errors():
+    fake_client = MagicMock()
+    fake_client.mark_stall_notified.side_effect = RuntimeError
+    adapter = Adapter()
+    with patch.object(adapter, "_get_client", return_value=fake_client):
+        # Must not raise
+        adapter.mark_stall_notified()

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

@@ -0,0 +1,41 @@
+"""Tests for openclaw_smart.runtime."""
+
+from __future__ import annotations
+
+import pytest
+from openclaw_smart import runtime
+
+
+@pytest.fixture(autouse=True)
+def _reset_host(monkeypatch):
+    """Ensure each test starts with the module-level host unset."""
+    monkeypatch.setattr(runtime, "_current_host", None)
+    monkeypatch.delenv(runtime.HOST_ENV, raising=False)
+    yield
+
+
+def test_default_host_is_openclaw():
+    assert runtime.host() == runtime.HOST_OPENCLAW
+    assert runtime.is_openclaw() is True
+
+
+def test_set_host_sets_module_state():
+    runtime.set_host("openclaw")
+    assert runtime.host() == "openclaw"
+    assert runtime.is_openclaw()
+
+
+def test_set_host_falls_back_for_unknown_value():
+    runtime.set_host("definitely-not-real")
+    assert runtime.host() == runtime.HOST_OPENCLAW
+
+
+def test_set_host_writes_env_var():
+    runtime.set_host("openclaw")
+    import os
+
+    assert os.environ.get(runtime.HOST_ENV) == "openclaw"
+
+
+def test_agent_version_is_openclaw():
+    assert runtime.agent_version() == "openclaw"