switchroom 0.12.27 → 0.12.29

package/vendor/hindsight-memory/tests/conftest.py

@@ -0,0 +1,94 @@
+"""Shared fixtures for Hindsight Claude Code plugin tests."""
+
+import io
+import json
+import os
+import sys
+import tempfile
+
+import pytest
+
+# Make scripts/ importable as the root — the hook scripts do:
+#   sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+# so lib.* imports resolve relative to scripts/
+SCRIPTS_DIR = os.path.join(os.path.dirname(__file__), "..", "scripts")
+if SCRIPTS_DIR not in sys.path:
+    sys.path.insert(0, os.path.abspath(SCRIPTS_DIR))
+
+
+@pytest.fixture()
+def state_dir(tmp_path, monkeypatch):
+    """Isolated state directory — prevents tests from touching real state files."""
+    d = tmp_path / "state"
+    d.mkdir()
+    monkeypatch.setenv("CLAUDE_PLUGIN_DATA", str(tmp_path))
+    return d
+
+
+@pytest.fixture()
+def plugin_root(tmp_path):
+    """Temp plugin root with a minimal settings.json."""
+    settings = tmp_path / "settings.json"
+    settings.write_text(json.dumps({}))
+    return tmp_path
+
+
+@pytest.fixture()
+def default_config(plugin_root, monkeypatch):
+    """Load config with no overrides, isolated from real settings.json."""
+    monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(plugin_root))
+    # Strip any real HINDSIGHT_* env vars that might bleed in
+    for key in list(os.environ):
+        if key.startswith("HINDSIGHT_"):
+            monkeypatch.delenv(key, raising=False)
+    from lib.config import load_config
+
+    return load_config()
+
+
+def make_hook_input(
+    prompt="What is the capital of France?",
+    session_id="sess-abc123",
+    cwd="/home/user/myproject",
+    transcript_path="",
+):
+    return {
+        "prompt": prompt,
+        "session_id": session_id,
+        "cwd": cwd,
+        "transcript_path": transcript_path,
+    }
+
+
+def make_transcript_file(tmp_path, messages):
+    """Write messages as a JSONL transcript file (flat test format)."""
+    f = tmp_path / "transcript.jsonl"
+    lines = [json.dumps(m) for m in messages]
+    f.write_text("\n".join(lines))
+    return str(f)
+
+
+def make_recall_response(memories):
+    """Build a fake /recall API response."""
+    return {"results": memories}
+
+
+def make_memory(text, mem_type="experience", mentioned_at="2024-01-15"):
+    return {"text": text, "type": mem_type, "mentioned_at": mentioned_at}
+
+
+class FakeHTTPResponse:
+    """Minimal urllib response mock."""
+
+    def __init__(self, data: dict, status: int = 200):
+        self.status = status
+        self._data = json.dumps(data).encode()
+
+    def read(self):
+        return self._data
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        pass

package/vendor/hindsight-memory/tests/test_bank.py

@@ -0,0 +1,142 @@
+"""Tests for lib/bank.py — bank ID derivation and mission management."""
+
+import json
+from unittest.mock import MagicMock
+
+import pytest
+
+from lib.bank import derive_bank_id, ensure_bank_mission
+
+
+def _cfg(**overrides):
+    base = {
+        "dynamicBankId": False,
+        "bankId": "claude-code",
+        "bankIdPrefix": "",
+        "agentName": "claude-code",
+        "dynamicBankGranularity": ["agent", "project"],
+        "bankMission": "",
+        "retainMission": None,
+    }
+    base.update(overrides)
+    return base
+
+
+def _hook(session_id="sess-1", cwd="/home/user/myproject"):
+    return {"session_id": session_id, "cwd": cwd}
+
+
+class TestDeriveBankIdStatic:
+    def test_static_default_bank(self):
+        assert derive_bank_id(_hook(), _cfg()) == "claude-code"
+
+    def test_static_custom_bank_id(self):
+        cfg = _cfg(bankId="my-agent")
+        assert derive_bank_id(_hook(), cfg) == "my-agent"
+
+    def test_static_with_prefix(self):
+        cfg = _cfg(bankId="bot", bankIdPrefix="prod")
+        assert derive_bank_id(_hook(), cfg) == "prod-bot"
+
+    def test_static_prefix_without_bankid_uses_default(self):
+        cfg = _cfg(bankId=None, bankIdPrefix="dev")
+        assert derive_bank_id(_hook(), cfg) == "dev-claude-code"
+
+
+class TestDeriveBankIdDynamic:
+    def test_dynamic_agent_project(self):
+        cfg = _cfg(dynamicBankId=True, agentName="mybot", dynamicBankGranularity=["agent", "project"])
+        result = derive_bank_id(_hook(cwd="/home/user/hindsight"), cfg)
+        assert result == "mybot::hindsight"
+
+    def test_dynamic_preserves_raw_special_chars(self):
+        cfg = _cfg(dynamicBankId=True, dynamicBankGranularity=["project"])
+        result = derive_bank_id(_hook(cwd="/home/user/my project"), cfg)
+        assert "my project" in result
+        assert "%" not in result
+
+    def test_dynamic_preserves_raw_utf8(self):
+        cfg = _cfg(dynamicBankId=True, dynamicBankGranularity=["project"])
+        result = derive_bank_id(_hook(cwd="/home/user/мой проект"), cfg)
+        assert "мой проект" in result
+        assert "%" not in result
+
+    def test_dynamic_session_field(self):
+        cfg = _cfg(dynamicBankId=True, dynamicBankGranularity=["session"])
+        result = derive_bank_id(_hook(session_id="abc-123"), cfg)
+        assert "abc-123" in result
+
+    def test_dynamic_with_prefix(self):
+        cfg = _cfg(dynamicBankId=True, dynamicBankGranularity=["agent"], bankIdPrefix="v2")
+        result = derive_bank_id(_hook(), cfg)
+        assert result.startswith("v2-")
+
+    def test_dynamic_channel_from_env(self, monkeypatch):
+        monkeypatch.setenv("HINDSIGHT_CHANNEL_ID", "telegram-123")
+        cfg = _cfg(dynamicBankId=True, dynamicBankGranularity=["channel"])
+        result = derive_bank_id(_hook(), cfg)
+        assert "telegram-123" in result
+
+    def test_dynamic_user_from_env(self, monkeypatch):
+        monkeypatch.setenv("HINDSIGHT_USER_ID", "user-456")
+        cfg = _cfg(dynamicBankId=True, dynamicBankGranularity=["user"])
+        result = derive_bank_id(_hook(), cfg)
+        assert "user-456" in result
+
+    def test_dynamic_missing_env_uses_defaults(self, monkeypatch):
+        monkeypatch.delenv("HINDSIGHT_CHANNEL_ID", raising=False)
+        monkeypatch.delenv("HINDSIGHT_USER_ID", raising=False)
+        cfg = _cfg(dynamicBankId=True, dynamicBankGranularity=["channel", "user"])
+        result = derive_bank_id(_hook(), cfg)
+        assert "default" in result
+        assert "anonymous" in result
+
+    def test_dynamic_empty_cwd_uses_unknown(self):
+        cfg = _cfg(dynamicBankId=True, dynamicBankGranularity=["project"])
+        result = derive_bank_id({"session_id": "s", "cwd": ""}, cfg)
+        assert "unknown" in result
+
+
+class TestEnsureBankMission:
+    def test_sets_mission_on_first_call(self, state_dir):
+        client = MagicMock()
+        cfg = _cfg(bankMission="You are a helpful assistant.", bankId="test-bank")
+        ensure_bank_mission(client, "test-bank", cfg)
+        client.set_bank_mission.assert_called_once_with(
+            "test-bank", "You are a helpful assistant.", retain_mission=None, timeout=10
+        )
+
+    def test_skips_if_already_set(self, state_dir):
+        client = MagicMock()
+        cfg = _cfg(bankMission="mission text")
+        ensure_bank_mission(client, "bank-a", cfg)
+        ensure_bank_mission(client, "bank-a", cfg)  # second call
+        assert client.set_bank_mission.call_count == 1
+
+    def test_skips_if_mission_empty(self, state_dir):
+        client = MagicMock()
+        cfg = _cfg(bankMission="")
+        ensure_bank_mission(client, "bank-b", cfg)
+        client.set_bank_mission.assert_not_called()
+
+    def test_includes_retain_mission_if_set(self, state_dir):
+        client = MagicMock()
+        cfg = _cfg(bankMission="reflect mission", retainMission="retain mission")
+        ensure_bank_mission(client, "bank-c", cfg)
+        client.set_bank_mission.assert_called_once_with(
+            "bank-c", "reflect mission", retain_mission="retain mission", timeout=10
+        )
+
+    def test_graceful_on_api_error(self, state_dir):
+        client = MagicMock()
+        client.set_bank_mission.side_effect = RuntimeError("server down")
+        cfg = _cfg(bankMission="mission")
+        # Should not raise
+        ensure_bank_mission(client, "bank-d", cfg)
+
+    def test_different_banks_each_set_once(self, state_dir):
+        client = MagicMock()
+        cfg = _cfg(bankMission="mission")
+        ensure_bank_mission(client, "bank-x", cfg)
+        ensure_bank_mission(client, "bank-y", cfg)
+        assert client.set_bank_mission.call_count == 2

package/vendor/hindsight-memory/tests/test_client.py

@@ -0,0 +1,232 @@
+"""Tests for lib/client.py — Hindsight REST API client."""
+
+import json
+import urllib.error
+from io import BytesIO
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from lib.client import USER_AGENT, HindsightClient, _validate_api_url
+
+
+class TestValidateApiUrl:
+    def test_valid_http(self):
+        assert _validate_api_url("http://localhost:9077") == "http://localhost:9077"
+
+    def test_valid_https(self):
+        assert _validate_api_url("https://api.example.com/") == "https://api.example.com"
+
+    def test_trailing_slash_stripped(self):
+        assert _validate_api_url("http://host:8080/") == "http://host:8080"
+
+    def test_invalid_scheme_raises(self):
+        with pytest.raises(ValueError, match="http or https"):
+            _validate_api_url("ftp://host")
+
+    def test_no_hostname_raises(self):
+        with pytest.raises(ValueError):
+            _validate_api_url("http://")
+
+
+class FakeResp:
+    def __init__(self, data, status=200):
+        self.status = status
+        self._body = json.dumps(data).encode()
+
+    def read(self):
+        return self._body
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        pass
+
+
+class TestHindsightClientInit:
+    def test_rejects_non_http_url(self):
+        with pytest.raises(ValueError):
+            HindsightClient("ftp://bad")
+
+    def test_stores_token(self):
+        c = HindsightClient("http://localhost:9077", api_token="tok123")
+        assert c.api_token == "tok123"
+
+    def test_no_token(self):
+        c = HindsightClient("http://localhost:9077")
+        assert c.api_token is None
+
+
+class TestHindsightClientRecall:
+    def test_posts_to_correct_path(self):
+        c = HindsightClient("http://localhost:9077")
+        response_data = {"results": [{"text": "Paris", "type": "world"}]}
+        with patch("urllib.request.urlopen", return_value=FakeResp(response_data)):
+            resp = c.recall("my-bank", "capital of France")
+        assert resp["results"][0]["text"] == "Paris"
+
+    def test_bank_id_url_encoded(self):
+        c = HindsightClient("http://localhost:9077")
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["url"] = req.full_url
+            return FakeResp({"results": []})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.recall("bank with spaces", "query")
+
+        assert "bank%20with%20spaces" in captured["url"]
+
+    def test_includes_auth_header_when_token_set(self):
+        c = HindsightClient("http://localhost:9077", api_token="mytoken")
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["headers"] = dict(req.headers)
+            return FakeResp({"results": []})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.recall("bank", "query")
+
+        assert "Authorization" in captured["headers"]
+        assert "mytoken" in captured["headers"]["Authorization"]
+
+    def test_no_auth_header_without_token(self):
+        c = HindsightClient("http://localhost:9077")
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["headers"] = dict(req.headers)
+            return FakeResp({"results": []})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.recall("bank", "query")
+
+        assert "Authorization" not in captured["headers"]
+
+    def test_sends_user_agent_header(self):
+        # Regression test for #1041: the stdlib default "Python-urllib/X.Y" UA
+        # is blocked by Cloudflare with error 1010, so we must always send our own.
+        c = HindsightClient("http://localhost:9077")
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["ua"] = req.get_header("User-agent")
+            return FakeResp({"results": []})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.recall("bank", "query")
+
+        assert captured["ua"] == USER_AGENT
+        assert captured["ua"].startswith("hindsight-claude-code/")
+
+    def test_http_error_raises_runtime_error(self):
+        c = HindsightClient("http://localhost:9077")
+        err = urllib.error.HTTPError(
+            url="http://localhost:9077/v1/default/banks/b/memories/recall",
+            code=500,
+            msg="Internal Server Error",
+            hdrs={},
+            fp=BytesIO(b"server exploded"),
+        )
+        with patch("urllib.request.urlopen", side_effect=err):
+            with pytest.raises(RuntimeError, match="HTTP 500"):
+                c.recall("b", "query")
+
+    def test_sends_budget_and_types(self):
+        c = HindsightClient("http://localhost:9077")
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["body"] = json.loads(req.data.decode())
+            return FakeResp({"results": []})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.recall("bank", "query", budget="high", types=["world", "experience"])
+
+        assert captured["body"]["budget"] == "high"
+        assert captured["body"]["types"] == ["world", "experience"]
+
+
+class TestHindsightClientRetain:
+    def test_posts_with_async_true(self):
+        c = HindsightClient("http://localhost:9077")
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["body"] = json.loads(req.data.decode())
+            return FakeResp({"status": "accepted"})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.retain("bank", "transcript content", document_id="doc-1", context="claude-code")
+
+        assert captured["body"]["async"] is True
+        assert captured["body"]["items"][0]["content"] == "transcript content"
+        assert captured["body"]["items"][0]["context"] == "claude-code"
+
+    def test_bank_id_encoded_in_retain_path(self):
+        c = HindsightClient("http://localhost:9077")
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["url"] = req.full_url
+            return FakeResp({})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.retain("my::bank", "content")
+
+        assert "my%3A%3Abank" in captured["url"]
+
+
+class TestHindsightClientHealthCheck:
+    def test_returns_true_on_200(self):
+        c = HindsightClient("http://localhost:9077")
+        with patch("urllib.request.urlopen", return_value=FakeResp({}, status=200)):
+            with patch("time.sleep"):  # don't actually sleep
+                assert c.health_check() is True
+
+    def test_returns_false_after_retries(self):
+        c = HindsightClient("http://localhost:9077")
+        with patch("urllib.request.urlopen", side_effect=OSError("refused")):
+            with patch("time.sleep"):
+                assert c.health_check() is False
+
+    def test_retries_on_failure(self):
+        c = HindsightClient("http://localhost:9077")
+        call_count = 0
+
+        def flaky(*_a, **_kw):
+            nonlocal call_count
+            call_count += 1
+            if call_count < 3:
+                raise OSError("not yet")
+            return FakeResp({}, status=200)
+
+        with patch("urllib.request.urlopen", side_effect=flaky):
+            with patch("time.sleep"):
+                result = c.health_check()
+
+        assert result is True
+        assert call_count == 3
+
+
+class TestHindsightClientSetBankMission:
+    def test_patches_config_endpoint(self):
+        c = HindsightClient("http://localhost:9077")
+        captured = {}
+
+        def fake_open(req, timeout=None):
+            captured["url"] = req.full_url
+            captured["method"] = req.method
+            captured["body"] = json.loads(req.data.decode())
+            return FakeResp({})
+
+        with patch("urllib.request.urlopen", side_effect=fake_open):
+            c.set_bank_mission("my-bank", "I am Claude", retain_mission="Extract facts")
+
+        assert captured["method"] == "PATCH"
+        assert "my-bank" in captured["url"]
+        assert captured["body"]["updates"]["reflect_mission"] == "I am Claude"
+        assert captured["body"]["updates"]["retain_mission"] == "Extract facts"

package/vendor/hindsight-memory/tests/test_config.py

@@ -0,0 +1,128 @@
+"""Tests for lib/config.py — configuration loading and env overrides."""
+
+import json
+import os
+
+import pytest
+
+from lib.config import _cast_env, load_config
+
+
+class TestCastEnv:
+    def test_bool_true_values(self):
+        for v in ("true", "True", "TRUE", "1", "yes", "YES"):
+            assert _cast_env(v, bool) is True
+
+    def test_bool_false_values(self):
+        for v in ("false", "False", "0", "no"):
+            assert _cast_env(v, bool) is False
+
+    def test_int_cast(self):
+        assert _cast_env("42", int) == 42
+
+    def test_int_invalid_returns_none(self):
+        assert _cast_env("notanint", int) is None
+
+    def test_str_passthrough(self):
+        assert _cast_env("hello", str) == "hello"
+
+
+class TestLoadConfig:
+    @pytest.fixture(autouse=True)
+    def _isolate_config(self, tmp_path, monkeypatch):
+        """Isolate from real user config and env vars."""
+        monkeypatch.setenv("HOME", str(tmp_path))
+        for k in list(os.environ):
+            if k.startswith("HINDSIGHT_"):
+                monkeypatch.delenv(k, raising=False)
+
+    def test_defaults_applied_when_no_settings_file(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        # No settings.json in tmp_path
+        cfg = load_config()
+        assert cfg["autoRecall"] is True
+        assert cfg["autoRetain"] is True
+        assert cfg["recallBudget"] == "mid"
+        assert cfg["retainEveryNTurns"] == 10
+
+    def test_settings_json_overrides_defaults(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        (tmp_path / "settings.json").write_text(json.dumps({"recallBudget": "high", "bankId": "my-bank"}))
+        cfg = load_config()
+        assert cfg["recallBudget"] == "high"
+        assert cfg["bankId"] == "my-bank"
+
+    def test_env_var_overrides_settings_json(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        (tmp_path / "settings.json").write_text(json.dumps({"recallBudget": "low"}))
+        monkeypatch.setenv("HINDSIGHT_RECALL_BUDGET", "high")
+        cfg = load_config()
+        assert cfg["recallBudget"] == "high"
+
+    def test_bool_env_var_override(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        monkeypatch.setenv("HINDSIGHT_AUTO_RECALL", "false")
+        cfg = load_config()
+        assert cfg["autoRecall"] is False
+
+    def test_int_env_var_override(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        monkeypatch.setenv("HINDSIGHT_API_PORT", "9999")
+        cfg = load_config()
+        assert cfg["apiPort"] == 9999
+
+    def test_invalid_settings_json_falls_back_to_defaults(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        (tmp_path / "settings.json").write_text("not valid json{{")
+        cfg = load_config()
+        assert cfg["recallBudget"] == "mid"  # default still applies
+
+    def test_null_values_in_settings_json_not_applied(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        (tmp_path / "settings.json").write_text(json.dumps({"bankId": None, "recallBudget": "high"}))
+        cfg = load_config()
+        # None values in file should not override defaults
+        assert cfg["bankId"] is None  # default is None, so ok
+        assert cfg["recallBudget"] == "high"
+
+    def test_api_url_env_override(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        monkeypatch.setenv("HINDSIGHT_API_URL", "http://myserver:8080")
+        cfg = load_config()
+        assert cfg["hindsightApiUrl"] == "http://myserver:8080"
+
+    def test_user_config_overrides_plugin_settings(self, tmp_path, monkeypatch):
+        plugin_root = tmp_path / "plugin"
+        plugin_root.mkdir()
+
+        # Plugin default ships with "low"
+        (plugin_root / "settings.json").write_text(json.dumps({"recallBudget": "low"}))
+        # User overrides to "high" via ~/.hindsight/claude-code.json
+        user_cfg = tmp_path / ".hindsight" / "claude-code.json"
+        user_cfg.parent.mkdir()
+        user_cfg.write_text(json.dumps({"recallBudget": "high"}))
+
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(plugin_root))
+        monkeypatch.setenv("HOME", str(tmp_path))
+        cfg = load_config()
+        assert cfg["recallBudget"] == "high"
+
+    def test_user_config_missing_falls_back_gracefully(self, tmp_path, monkeypatch):
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(tmp_path))
+        # HOME points to tmp_path where no .hindsight/claude-code.json exists
+        monkeypatch.setenv("HOME", str(tmp_path))
+        cfg = load_config()
+        assert cfg["recallBudget"] == "mid"  # default
+
+    def test_env_var_wins_over_user_config(self, tmp_path, monkeypatch):
+        plugin_root = tmp_path / "plugin"
+        plugin_root.mkdir()
+        user_cfg_dir = tmp_path / ".hindsight"
+        user_cfg_dir.mkdir()
+        (user_cfg_dir / "claude-code.json").write_text(json.dumps({"recallBudget": "low"}))
+
+        monkeypatch.setenv("CLAUDE_PLUGIN_ROOT", str(plugin_root))
+        monkeypatch.setenv("HOME", str(tmp_path))
+        monkeypatch.setenv("HINDSIGHT_RECALL_BUDGET", "high")
+        cfg = load_config()
+        assert cfg["recallBudget"] == "high"