claude-smart 0.2.45 → 0.2.47

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/tests/integration/test_recursion_guard_integration.py

@@ -0,0 +1,86 @@
+"""Integration: hook silently no-ops when OPENCLAW_SMART_INTERNAL=1.
+
+This guard prevents an infinite feedback loop where the reflexio backend's
+own openclaw subprocess (the openclaw LLM provider) re-enters openclaw-smart
+and republishes the extractor's system prompt back into reflexio.
+"""
+
+from __future__ import annotations
+
+import io
+import json
+from pathlib import Path
+
+import pytest
+
+pytestmark = pytest.mark.integration
+
+
+@pytest.fixture
+def isolated_state(monkeypatch, tmp_path: Path) -> Path:
+    """Force state.py to write under tmp_path so the test never touches ~/.openclaw-smart/."""
+    state_dir = tmp_path / "sessions"
+    monkeypatch.setenv("OPENCLAW_SMART_STATE_DIR", str(state_dir))
+    return state_dir
+
+
+def test_hook_short_circuits_when_internal_env_set(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    isolated_state: Path,
+) -> None:
+    """With OPENCLAW_SMART_INTERNAL=1, every handler is bypassed and stdout is empty."""
+    monkeypatch.setenv("OPENCLAW_SMART_INTERNAL", "1")
+
+    from openclaw_smart import hook
+
+    payload = {
+        "event": {"prompt": "anything"},
+        "ctx": {"sessionKey": "internal-1", "agentId": "a"},
+    }
+    monkeypatch.setattr("sys.stdin", io.StringIO(json.dumps(payload)))
+
+    rc = hook.main(["openclaw", "before-prompt-build"])
+    assert rc == 0
+
+    # No session JSONL should have been created — the handler bailed before
+    # ever touching state.append().
+    assert not isolated_state.exists() or not list(isolated_state.glob("*.jsonl"))
+
+    out = capsys.readouterr().out
+    # The TS shim treats empty stdout as "no return value" per the design.
+    assert out.strip() == ""
+
+
+def test_hook_short_circuits_when_workspace_inside_reflexio(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+    isolated_state: Path,
+    tmp_path: Path,
+) -> None:
+    """A workspaceDir inside the reflexio install dir is also treated as internal.
+
+    The reflexio backend cwd's into its own checkout when it spawns the openclaw
+    subprocess for the LLM provider. internal_call.is_internal_invocation honours
+    this so the recursion guard fires even if the env var got stripped.
+    """
+    import reflexio
+
+    reflexio_pkg_dir = Path(reflexio.__file__).resolve().parent
+    payload = {
+        "event": {"prompt": "anything"},
+        "ctx": {
+            "sessionKey": "internal-2",
+            "agentId": "a",
+            "workspaceDir": str(reflexio_pkg_dir / "sub"),
+        },
+    }
+    monkeypatch.setattr("sys.stdin", io.StringIO(json.dumps(payload)))
+
+    from openclaw_smart import hook
+
+    rc = hook.main(["openclaw", "before-prompt-build"])
+    assert rc == 0
+    out = capsys.readouterr().out
+    assert out.strip() == ""
+    assert not isolated_state.exists() or not list(isolated_state.glob("*.jsonl"))

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/tests/integration/test_search_inject_integration.py

@@ -0,0 +1,144 @@
+"""Integration: search reflexio, render the hits, assert the prependContext envelope.
+
+Two flavours of coverage:
+
+* **live-backend path** — when reflexio is reachable at ``REFLEXIO_URL``, run
+  ``context_inject.emit_context`` end-to-end and assert the expected envelope
+  shape. Skipped automatically when the backend isn't running.
+* **stub path** — replace ``Adapter.search_all`` with a fixed return value so
+  the rendering + envelope-emit logic is exercised regardless of environment.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from io import StringIO
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+pytestmark = pytest.mark.integration
+
+
+def _reflexio_url() -> str:
+    return os.environ.get("REFLEXIO_URL", "http://localhost:8061/")
+
+
+def _backend_alive(url: str) -> bool:
+    import urllib.error
+    import urllib.request
+
+    health = url.rstrip("/") + "/health"
+    try:
+        with urllib.request.urlopen(health, timeout=1.5) as resp:  # nosec — local only
+            return resp.status == 200
+    except (urllib.error.URLError, TimeoutError, OSError):
+        return False
+
+
+@pytest.fixture
+def isolated_state(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> Path:
+    state_dir = tmp_path / "sessions"
+    monkeypatch.setenv("OPENCLAW_SMART_STATE_DIR", str(state_dir))
+    return state_dir
+
+
+def _parse_emitted(captured: StringIO) -> dict | None:
+    raw = captured.getvalue().strip()
+    if not raw:
+        return None
+    return json.loads(raw)
+
+
+def test_emit_context_returns_false_when_search_empty(
+    monkeypatch: pytest.MonkeyPatch, isolated_state: Path
+) -> None:
+    """No hits → no envelope, no JSONL side-effect."""
+    from openclaw_smart import context_inject
+
+    captured = StringIO()
+    monkeypatch.setattr(sys, "stdout", captured)
+
+    fake_adapter = MagicMock()
+    fake_adapter.search_all.return_value = ([], [], [])
+
+    emitted = context_inject.emit_context(
+        session_id="sess-empty",
+        project_id="proj-1",
+        query="anything",
+        top_k=3,
+        adapter=fake_adapter,
+    )
+    assert emitted is False
+    assert _parse_emitted(captured) is None
+    assert not (isolated_state / "sess-empty.injected.jsonl").exists()
+
+
+def test_emit_context_wraps_hits_in_prependContext_envelope(
+    monkeypatch: pytest.MonkeyPatch, isolated_state: Path
+) -> None:
+    """A stubbed user playbook is rendered as markdown under ``prependContext``."""
+    from openclaw_smart import context_inject
+
+    captured = StringIO()
+    monkeypatch.setattr(sys, "stdout", captured)
+
+    user_playbook = {
+        "content": "Always validate user input before persistence.",
+        "trigger": "any external string lands in the persistence layer",
+        "rationale": "blocks a whole class of injection bugs",
+        "user_playbook_id": "pb-1",
+    }
+    fake_adapter = MagicMock()
+    fake_adapter.search_all.return_value = ([user_playbook], [], [])
+
+    emitted = context_inject.emit_context(
+        session_id="sess-hit",
+        project_id="proj-1",
+        query="how do I validate user input",
+        top_k=3,
+        adapter=fake_adapter,
+    )
+
+    assert emitted is True
+    payload = _parse_emitted(captured)
+    assert payload is not None
+    md = payload.get("prependContext")
+    assert md, f"expected prependContext markdown, got {payload!r}"
+    # Title text shows up inside the rendered markdown.
+    assert "validate user input" in md.lower()
+    # Citation registry was persisted for the agent_end hook to consume.
+    assert (isolated_state / "sess-hit.injected.jsonl").exists()
+
+
+def test_emit_context_against_live_backend(
+    monkeypatch: pytest.MonkeyPatch, isolated_state: Path
+) -> None:
+    """When a real backend is running, the full pipeline executes without error.
+
+    No fixture data is seeded — the backend may legitimately return zero hits;
+    the assertion is that the call completes, not that there's data to inject.
+    """
+    if not _backend_alive(_reflexio_url()):
+        pytest.skip(f"reflexio backend not reachable at {_reflexio_url()}")
+
+    from openclaw_smart import context_inject
+
+    captured = StringIO()
+    monkeypatch.setattr(sys, "stdout", captured)
+
+    # No assertion on emitted bool — backend state is environment-dependent.
+    context_inject.emit_context(
+        session_id="sess-live",
+        project_id="proj-live",
+        query="ping",
+        top_k=3,
+    )
+    # If markdown was emitted it should at least be valid JSON with the right key.
+    raw = captured.getvalue().strip()
+    if raw:
+        payload = json.loads(raw)
+        assert "prependContext" in payload

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

@@ -0,0 +1,184 @@
+"""Tests for openclaw_smart.cli."""
+
+from __future__ import annotations
+
+from argparse import Namespace
+from unittest.mock import patch
+
+import pytest
+from openclaw_smart import cli
+
+
+@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_cmd_show_fetches_all_entities(capsys):
+    with (
+        patch("openclaw_smart.cli.Adapter") as Ad,
+        patch("openclaw_smart.cli.ids.resolve_project_id", return_value="proj-x"),
+    ):
+        Ad.return_value.fetch_all.return_value = ([], [], [])
+        rc = cli.cmd_show(Namespace(project=None))
+    assert rc == 0
+    out = capsys.readouterr().out
+    assert "proj-x" in out
+
+
+def test_cmd_show_renders_markdown(capsys):
+    with (
+        patch("openclaw_smart.cli.Adapter") as Ad,
+        patch("openclaw_smart.cli.ids.resolve_project_id", return_value="proj-x"),
+    ):
+        Ad.return_value.fetch_all.return_value = (
+            [{"user_playbook_id": "abc", "content": "Test rule"}],
+            [],
+            [],
+        )
+        cli.cmd_show(Namespace(project=None))
+    out = capsys.readouterr().out
+    assert "Test rule" in out
+    assert "[oc:" in out
+
+
+def test_cmd_show_honors_project_override(capsys):
+    with (
+        patch("openclaw_smart.cli.Adapter") as Ad,
+        patch("openclaw_smart.cli.ids.resolve_project_id", return_value="ignored"),
+    ):
+        Ad.return_value.fetch_all.return_value = ([], [], [])
+        cli.cmd_show(Namespace(project="explicit-proj"))
+    Ad.return_value.fetch_all.assert_called_once()
+    kwargs = Ad.return_value.fetch_all.call_args[1]
+    assert kwargs["project_id"] == "explicit-proj"
+
+
+def test_cmd_learn_no_session_returns_zero(isolate_state_dir):
+    rc = cli.cmd_learn(Namespace(session=None, project=None, note=None))
+    assert rc == 0
+
+
+def test_cmd_learn_force_extracts(isolate_state_dir):
+    # Seed a session JSONL so _latest_session_id picks it up.
+    from openclaw_smart import state
+
+    state.append("sess-1", {"role": "User", "content": "x"})
+    with (
+        patch("openclaw_smart.cli.publish") as pub,
+        patch("openclaw_smart.cli.ids.resolve_project_id", return_value="proj-x"),
+    ):
+        pub.publish_unpublished.return_value = ("ok", 1)
+        rc = cli.cmd_learn(Namespace(session=None, project=None, note=None))
+    assert rc == 0
+    kwargs = pub.publish_unpublished.call_args[1]
+    assert kwargs["force_extraction"] is True
+    assert kwargs["session_id"] == "sess-1"
+
+
+def test_cmd_learn_appends_note(isolate_state_dir):
+    from openclaw_smart import state
+
+    state.append("sess-2", {"role": "User", "content": "earlier"})
+    with (
+        patch("openclaw_smart.cli.publish") as pub,
+        patch("openclaw_smart.cli.ids.resolve_project_id", return_value="proj-x"),
+    ):
+        pub.publish_unpublished.return_value = ("ok", 2)
+        cli.cmd_learn(Namespace(session="sess-2", project=None, note="key insight"))
+    records = state.read_all("sess-2")
+    contents = [r.get("content") for r in records]
+    assert "key insight" in contents
+
+
+def test_cmd_learn_handles_unreachable_backend(isolate_state_dir, capsys):
+    from openclaw_smart import state
+
+    state.append("sess-3", {"role": "User", "content": "x"})
+    with (
+        patch("openclaw_smart.cli.publish") as pub,
+        patch("openclaw_smart.cli.ids.resolve_project_id", return_value="proj-x"),
+    ):
+        pub.publish_unpublished.return_value = ("failed", 0)
+        rc = cli.cmd_learn(Namespace(session=None, project=None, note=None))
+    assert rc == 1
+    assert "Failed to reach reflexio" in capsys.readouterr().out
+
+
+def test_cmd_clear_all_requires_yes(capsys):
+    with patch("openclaw_smart.cli._resolve_clear_all_targets", return_value=[]):
+        rc = cli.cmd_clear_all(Namespace(yes=False))
+    assert rc != 0
+    assert "--yes" in capsys.readouterr().out
+
+
+def test_cmd_clear_all_with_yes_proceeds(monkeypatch, tmp_path):
+    sessions = tmp_path / "sessions"
+    sessions.mkdir()
+    (sessions / "old.jsonl").write_text('{"role":"User"}\n')
+    monkeypatch.setenv("OPENCLAW_SMART_STATE_DIR", str(sessions))
+
+    with (
+        patch("openclaw_smart.cli._resolve_clear_all_targets", return_value=[]),
+        patch("openclaw_smart.cli._service_status", return_value="not running"),
+        patch("openclaw_smart.cli._run_service", return_value=0),
+    ):
+        rc = cli.cmd_clear_all(Namespace(yes=True))
+    assert rc == 0
+    assert not (sessions / "old.jsonl").exists()
+
+
+def test_cmd_clear_all_restarts_backend_after_delete_failure(tmp_path):
+    target = cli._ClearAllTarget(
+        path=tmp_path / "reflexio-openclaw-test",
+        kind="dir",
+        label="test target",
+    )
+    service_calls: list[str] = []
+
+    def fake_run_service(_script, command) -> int:  # noqa: ANN001
+        service_calls.append(command)
+        return 0
+
+    with (
+        patch("openclaw_smart.cli._resolve_clear_all_targets", return_value=[target]),
+        patch("openclaw_smart.cli._service_status", return_value="running on 8071"),
+        patch(
+            "openclaw_smart.cli._remove_clear_all_target",
+            side_effect=cli._ClearAllError("boom"),
+        ),
+        patch("openclaw_smart.cli._run_service", side_effect=fake_run_service),
+    ):
+        rc = cli.cmd_clear_all(Namespace(yes=True))
+
+    assert rc == 1
+    assert service_calls == ["stop", "start"]
+
+
+def test_build_parser_accepts_show():
+    parser = cli._build_parser()
+    args = parser.parse_args(["show"])
+    assert args.command == "show"
+    assert args.project is None
+
+
+def test_build_parser_accepts_learn_with_note():
+    parser = cli._build_parser()
+    args = parser.parse_args(["learn", "--note", "hello"])
+    assert args.command == "learn"
+    assert args.note == "hello"
+
+
+def test_build_parser_accepts_clear_all_yes():
+    parser = cli._build_parser()
+    args = parser.parse_args(["clear-all", "--yes"])
+    assert args.yes is True
+
+
+def test_build_parser_accepts_restart_flags():
+    parser = cli._build_parser()
+    args = parser.parse_args(["restart", "--skip-backend", "--no-rebuild"])
+    assert args.skip_backend is True
+    assert args.no_rebuild is True

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

@@ -0,0 +1,142 @@
+"""Tests for openclaw_smart.events.after_tool_call."""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+from openclaw_smart.events import after_tool_call as atc
+
+
+@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_handle_records_tool_invocation_camelcase(isolate_state_dir):
+    """openClaw delivers camelCase fields; handler translates to snake_case."""
+    atc.handle(
+        {
+            "sessionKey": "s1",
+            "toolName": "Bash",
+            "params": {"command": "ls"},
+            "result": "file1.txt",
+            "agentId": "a",
+        }
+    )
+    records = _read_records(isolate_state_dir)
+    assert len(records) == 1
+    rec = records[0]
+    assert rec["role"] == "Assistant_tool"
+    assert rec["tool_name"] == "Bash"
+    assert rec["tool_input"] == {"command": "ls"}
+    assert rec["tool_output"] == "file1.txt"
+    assert rec["status"] == "success"
+
+
+def test_handle_accepts_snake_case_fallback(isolate_state_dir):
+    """Already-translated payloads work too."""
+    atc.handle(
+        {
+            "sessionKey": "s2",
+            "tool_name": "Edit",
+            "tool_input": {"file_path": "x.py", "new_string": "hi"},
+            "tool_response": "ok",
+            "status": "success",
+        }
+    )
+    records = _read_records(isolate_state_dir, "s2")
+    assert records[0]["tool_name"] == "Edit"
+    assert records[0]["tool_input"]["file_path"] == "x.py"
+
+
+def test_handle_redacts_high_entropy_secrets(isolate_state_dir):
+    secret_command = "API_KEY=AbCdEfGhIj1234567890QwErTyUiOp curl ..."
+    atc.handle(
+        {
+            "sessionKey": "s3",
+            "toolName": "Bash",
+            "params": {"command": secret_command},
+            "result": "",
+        }
+    )
+    records = _read_records(isolate_state_dir, "s3")
+    command = records[0]["tool_input"]["command"]
+    assert "AbCdEfGhIj1234567890QwErTyUiOp" not in command
+    assert "<redacted:" in command
+
+
+def test_handle_does_not_redact_simple_assignments(isolate_state_dir):
+    """LOG_LEVEL=INFO should not be redacted — too short and not entropy-y."""
+    atc.handle(
+        {
+            "sessionKey": "s4",
+            "toolName": "Bash",
+            "params": {"command": "LOG_LEVEL=INFO some_cmd"},
+            "result": "",
+        }
+    )
+    records = _read_records(isolate_state_dir, "s4")
+    assert "LOG_LEVEL=INFO" in records[0]["tool_input"]["command"]
+
+
+def test_handle_classifies_error_status(isolate_state_dir):
+    atc.handle(
+        {
+            "sessionKey": "s5",
+            "toolName": "Bash",
+            "params": {"command": "false"},
+            "result": {"is_error": True, "error": "exit 1"},
+        }
+    )
+    records = _read_records(isolate_state_dir, "s5")
+    assert records[0]["status"] == "error"
+    assert "exit 1" in records[0]["tool_output"]
+
+
+def test_handle_flattens_bash_dict_output(isolate_state_dir):
+    atc.handle(
+        {
+            "sessionKey": "s6",
+            "toolName": "Bash",
+            "params": {"command": "echo hi"},
+            "result": {"stdout": "hi", "stderr": ""},
+        }
+    )
+    records = _read_records(isolate_state_dir, "s6")
+    assert records[0]["tool_output"] == "hi"
+
+
+def test_handle_skips_when_no_session_id(isolate_state_dir):
+    atc.handle({"toolName": "Bash", "params": {"command": "ls"}})
+    assert _read_records(isolate_state_dir) == []
+
+
+def test_handle_skips_when_no_tool_name(isolate_state_dir):
+    atc.handle({"sessionKey": "s7", "params": {"command": "ls"}})
+    assert _read_records(isolate_state_dir, "s7") == []
+
+
+def test_handle_truncates_long_output(isolate_state_dir):
+    long_output = "x" * 5000
+    atc.handle(
+        {
+            "sessionKey": "s8",
+            "toolName": "Bash",
+            "params": {"command": "cat large_file"},
+            "result": long_output,
+        }
+    )
+    records = _read_records(isolate_state_dir, "s8")
+    output = records[0]["tool_output"]
+    assert "truncated" in output
+    assert len(output) < 5000