switchroom 0.16.47 → 0.17.1

package/vendor/hindsight-memory/scripts/tests/test_config_client_casts.py

@@ -0,0 +1,111 @@
+"""Unit tests for config env casting (`lib.config._cast_env`) and the
+client's request-timeout override clamp (`HindsightClient._resolve_timeout`).
+
+Follow-ups from the #2816 review punch list:
+  - list cast: a value that parses as JSON but is NOT a list (e.g. `42`)
+    must return None (keep default, fail-open) instead of falling through
+    to comma-split and producing a junk one-element list. Malformed
+    intended-JSON (`[1,2`) also keeps the default; plain comma strings
+    still split.
+  - timeout override: zero/negative env values are clamped to >= 1 instead
+    of passing straight through to urlopen.
+
+Stdlib-only.
+"""
+
+import os
+import sys
+import unittest
+
+SCRIPTS_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+if SCRIPTS_DIR not in sys.path:
+    sys.path.insert(0, SCRIPTS_DIR)
+
+from lib.config import _cast_env  # noqa: E402
+from lib.client import HindsightClient  # noqa: E402
+
+
+class CastEnvListTests(unittest.TestCase):
+    def test_valid_json_list(self):
+        self.assertEqual(_cast_env('["a", "b"]', list), ["a", "b"])
+
+    def test_empty_json_list(self):
+        self.assertEqual(_cast_env("[]", list), [])
+
+    def test_comma_string_splits(self):
+        self.assertEqual(_cast_env("a, b ,c", list), ["a", "b", "c"])
+
+    def test_comma_string_drops_empty_tokens(self):
+        self.assertEqual(_cast_env("a,,b,", list), ["a", "b"])
+
+    def test_single_bare_string(self):
+        # Not valid JSON, no commas → one-element list.
+        self.assertEqual(_cast_env("solo", list), ["solo"])
+
+    def test_json_non_list_scalar_returns_none(self):
+        # Parses as JSON int — not a list, not a comma string. Default kept.
+        self.assertIsNone(_cast_env("42", list))
+
+    def test_json_non_list_object_returns_none(self):
+        self.assertIsNone(_cast_env('{"a": 1}', list))
+
+    def test_json_string_returns_none(self):
+        # A JSON-quoted string is valid JSON but not a list.
+        self.assertIsNone(_cast_env('"tag"', list))
+
+    def test_malformed_json_array_returns_none(self):
+        # Looks like intended JSON but doesn't parse → default kept,
+        # NOT comma-split into junk like ['["a"', '"b"'].
+        self.assertIsNone(_cast_env('["a", "b"', list))
+
+    def test_malformed_json_object_returns_none(self):
+        self.assertIsNone(_cast_env('{"a": ', list))
+
+
+class CastEnvOtherTypesTests(unittest.TestCase):
+    """Guard the neighbours the list change must not disturb."""
+
+    def test_int_valid(self):
+        self.assertEqual(_cast_env("30", int), 30)
+
+    def test_int_invalid_returns_none(self):
+        self.assertIsNone(_cast_env("thirty", int))
+
+    def test_bool_true_variants(self):
+        for v in ("true", "1", "yes", "TRUE"):
+            self.assertTrue(_cast_env(v, bool), v)
+
+    def test_bool_false(self):
+        self.assertFalse(_cast_env("false", bool))
+
+    def test_dict_valid(self):
+        self.assertEqual(_cast_env('{"a": 1}', dict), {"a": 1})
+
+    def test_dict_non_container_returns_none(self):
+        self.assertIsNone(_cast_env("42", dict))
+
+
+class ResolveTimeoutTests(unittest.TestCase):
+    URL = "http://127.0.0.1:9999"
+
+    def _client(self, override):
+        return HindsightClient(self.URL, request_timeout_override=override)
+
+    def test_no_override_uses_caller_timeout(self):
+        self.assertEqual(self._client(None)._resolve_timeout(30), 30)
+
+    def test_valid_override_wins(self):
+        self.assertEqual(self._client(15)._resolve_timeout(30), 15)
+
+    def test_zero_override_clamped_to_one(self):
+        self.assertEqual(self._client(0)._resolve_timeout(30), 1)
+
+    def test_negative_override_clamped_to_one(self):
+        self.assertEqual(self._client(-5)._resolve_timeout(30), 1)
+
+    def test_one_passes_through(self):
+        self.assertEqual(self._client(1)._resolve_timeout(30), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/vendor/hindsight-memory/scripts/tests/test_recall_context_slice.py

@@ -0,0 +1,126 @@
+"""Switchroom follow-up to #2830 — recall-side coverage of the tool-boundary
+slice fix.
+
+#2830 fixed silent-memory-loss in ``slice_last_turns_by_user_boundary``:
+Claude Code emits tool results as ``role="user"`` messages, and the old
+boundary counter treated each one as a turn. A tool-heavy turn (>=N sequential
+tool rounds) could therefore fill a fixed-size window with tool_result
+pseudo-turns and push the real human message OUTSIDE it.
+
+That same slice function backs TWO call sites:
+  1. the RETAIN window (covered by ``test_retain_window.py``), and
+  2. the RECALL context slice, via ``compose_recall_query``.
+
+#2830 shipped a test only for the retain path. This file closes the reviewer
+nit by exercising the RECALL path end-to-end over a tool-heavy transcript:
+the composed recall query must still carry the real human turn's text and must
+not be truncated at the tool_result pseudo-boundaries.
+
+These tests FAIL if the ``_is_tool_result_only_user_message`` guard is reverted
+(the tool_result messages become boundaries again and the human turn is sliced
+off), and pass with the guard in place.
+
+Stdlib-only; runs under ``python3 -m unittest discover tests/``.
+"""
+
+import os
+import sys
+import unittest
+
+SCRIPTS_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+if SCRIPTS_DIR not in sys.path:
+    sys.path.insert(0, SCRIPTS_DIR)
+
+from lib.content import compose_recall_query  # noqa: E402
+
+
+def _human_msg(text: str) -> dict:
+    return {"role": "user", "content": text}
+
+
+def _assistant_msg(text: str) -> dict:
+    return {"role": "assistant", "content": text}
+
+
+def _tool_result_msg(tool_use_id: str, text: str) -> dict:
+    # Claude Code emits tool results as role="user" with a content list of
+    # tool_result blocks — exactly the shape read_transcript() produces.
+    return {
+        "role": "user",
+        "content": [{"type": "tool_result", "tool_use_id": tool_use_id, "content": text}],
+    }
+
+
+class ComposeRecallQueryToolHeavyTurn(unittest.TestCase):
+    """The recall context slice must count HUMAN turns, not tool_result
+    pseudo-turns — otherwise a tool-heavy turn drops the human's text from the
+    recall query, so recall searches on the tool output instead of what the
+    human actually said.
+    """
+
+    def test_tool_heavy_prior_turn_keeps_human_text_in_recall_context(self):
+        # A prior human turn stating a fact, then 3 sequential tool rounds,
+        # then the assistant answer. The current (latest) query is separate.
+        # recall_context_turns=2 asks for the latest turn + one prior HUMAN
+        # turn. OLD boundary semantics count the 3 tool_result "user" messages
+        # as turns and never reach the human fact; NEW semantics skip them and
+        # anchor to the real human turn, so its text lands in "Prior context:".
+        prior_fact = "my prod database is called ORCHID_PRIMARY"
+        messages = [
+            _human_msg(prior_fact),
+            _assistant_msg("let me look that up"),
+            _tool_result_msg("t1", "queried schema table 1"),
+            _assistant_msg("checking more"),
+            _tool_result_msg("t2", "queried schema table 2"),
+            _assistant_msg("one more"),
+            _tool_result_msg("t3", "queried schema table 3"),
+            _assistant_msg("here is your schema"),
+        ]
+        result = compose_recall_query(
+            "what port does it listen on",
+            messages,
+            recall_context_turns=2,
+        )
+        self.assertIn("Prior context:", result)
+        self.assertIn(
+            "ORCHID_PRIMARY",
+            result,
+            "human turn text was sliced out of the recall context by the "
+            "tool_result pseudo-boundaries (recall-side silent memory loss). "
+            "Composed query was: " + repr(result),
+        )
+        # The tool_result content must NOT leak in as if it were a human turn.
+        self.assertNotIn("queried schema table", result)
+
+    def test_recall_context_anchors_to_human_turns_across_tool_volume(self):
+        # Two prior human turns, the older one carrying a fact, each turn
+        # followed by tool rounds. recall_context_turns=3 (latest + 2 prior
+        # HUMAN turns) must reach back past ALL the tool_result messages to the
+        # oldest human turn — tool volume must not consume the turn budget.
+        oldest_fact = "the deploy key is FALCON_9_KEY"
+        messages = [
+            _human_msg(oldest_fact),
+            _assistant_msg("looking"),
+            _tool_result_msg("t1", "tool output alpha"),
+            _assistant_msg("more"),
+            _tool_result_msg("t2", "tool output beta"),
+            _human_msg("and remind me of the region too"),
+            _assistant_msg("checking region"),
+            _tool_result_msg("t3", "tool output gamma"),
+            _assistant_msg("region is ap-southeast-2"),
+        ]
+        result = compose_recall_query(
+            "put those together for me",
+            messages,
+            recall_context_turns=3,
+        )
+        self.assertIn("Prior context:", result)
+        # Both prior HUMAN turns survive; the oldest human fact is reached.
+        self.assertIn("FALCON_9_KEY", result)
+        self.assertIn("and remind me of the region too", result)
+        # No tool_result payload masquerades as human context.
+        self.assertNotIn("tool output", result)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/vendor/hindsight-memory/scripts/tests/test_recall_integration.py

@@ -55,13 +55,35 @@ class _FakeClient:
         self._memories = memories if memories is not None else []
         self._recall_exc = recall_exc
         self._list_exc = list_exc
+        # One entry per recall() call — lets tests assert the tag-filter
+        # kwargs (upstream 962140eef) that main() passed per bank.
+        self.recall_calls = []
 
     def list_directives(self, bank_id, active_only=True, timeout=2):
         if self._list_exc is not None:
             raise self._list_exc
         return {"items": list(self._directives)}
 
-    def recall(self, bank_id, query, max_tokens=1024, budget="mid", types=None, timeout=10):
+    def recall(
+        self,
+        bank_id,
+        query,
+        max_tokens=1024,
+        budget="mid",
+        types=None,
+        tags=None,
+        tags_match=None,
+        tag_groups=None,
+        timeout=10,
+    ):
+        self.recall_calls.append(
+            {
+                "bank_id": bank_id,
+                "tags": tags,
+                "tags_match": tags_match,
+                "tag_groups": tag_groups,
+            }
+        )
         if self._recall_exc is not None:
             raise self._recall_exc
         return {"results": list(self._memories)}
@@ -617,5 +639,67 @@ class OverlapGateIntegrationTests(unittest.TestCase):
         self.assertIsNone(ctx)
 
 
+class RecallTagFilterIntegrationTests(unittest.TestCase):
+    """Upstream 962140eef port — tag filters flow through main() to each
+    per-bank recall call, composed with our additional-banks routing."""
+
+    def test_global_tags_passed_to_primary_bank(self):
+        client = _FakeClient(memories=[_memory("a fact")])
+        _run_main_with(
+            client,
+            config_extra={
+                "recallTags": ["memory_type:rule"],
+                "recallTagsMatch": "any_strict",
+            },
+        )
+        self.assertEqual(client.recall_calls[0]["tags"], ["memory_type:rule"])
+        self.assertEqual(client.recall_calls[0]["tags_match"], "any_strict")
+
+    def test_no_tags_match_sent_without_tags_or_groups(self):
+        client = _FakeClient(memories=[_memory("a fact")])
+        _run_main_with(client, config_extra={"recallTagsMatch": "all"})
+        self.assertIsNone(client.recall_calls[0]["tags"])
+        self.assertIsNone(client.recall_calls[0]["tags_match"])
+        self.assertIsNone(client.recall_calls[0]["tag_groups"])
+
+    def test_per_bank_filter_overrides_global_for_additional_bank(self):
+        client = _FakeClient(memories=[_memory("a fact")])
+        _run_main_with(
+            client,
+            config_extra={
+                "recallAdditionalBanks": ["shared-bank"],
+                "recallTags": ["tech_stack:supabase"],
+                "recallTagsMatch": "any",
+                "recallAdditionalBankFilters": {
+                    "shared-bank": {
+                        "recallTags": ["memory_type:rule"],
+                        "recallTagsMatch": "all_strict",
+                    }
+                },
+            },
+        )
+        primary, extra = client.recall_calls[0], client.recall_calls[1]
+        self.assertEqual(primary["bank_id"], "test-bank")
+        self.assertEqual(primary["tags"], ["tech_stack:supabase"])
+        self.assertEqual(primary["tags_match"], "any")
+        self.assertEqual(extra["bank_id"], "shared-bank")
+        self.assertEqual(extra["tags"], ["memory_type:rule"])
+        self.assertEqual(extra["tags_match"], "all_strict")
+
+    def test_additional_bank_without_override_inherits_global(self):
+        client = _FakeClient(memories=[_memory("a fact")])
+        _run_main_with(
+            client,
+            config_extra={
+                "recallAdditionalBanks": ["shared-bank"],
+                "recallTags": ["memory_type:rule"],
+            },
+        )
+        extra = client.recall_calls[1]
+        self.assertEqual(extra["tags"], ["memory_type:rule"])
+        # Global tags_match defaults are only sent when filters are active.
+        self.assertEqual(extra["tags_match"], None)
+
+
 if __name__ == "__main__":
     unittest.main()

package/vendor/hindsight-memory/scripts/tests/test_recall_tag_filters.py

@@ -0,0 +1,107 @@
+"""Unit tests for the recall tag-filter port (upstream 962140eef).
+
+Covers the switchroom-specific composition points that upstream's own tests
+cannot: the tag-filter fingerprint (`_tag_filter_sig`) and its inclusion in
+the recall cache key (`_cache_key`). Tag filters change what the recall API
+returns for an identical query, so a filter change within the cache TTL must
+produce a cache MISS — otherwise stale, differently-filtered results would
+be served.
+
+Stdlib-only.
+"""
+
+import os
+import sys
+import unittest
+
+SCRIPTS_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+if SCRIPTS_DIR not in sys.path:
+    sys.path.insert(0, SCRIPTS_DIR)
+
+import recall  # noqa: E402
+
+
+class TagFilterSigTests(unittest.TestCase):
+    def test_empty_filters_collapse_to_empty_string(self):
+        # Backward-compat: unused feature must not perturb existing keys.
+        self.assertEqual(recall._tag_filter_sig(None, None, None, {}), "")
+        self.assertEqual(recall._tag_filter_sig([], None, None, {}), "")
+
+    def test_tags_produce_nonempty_sig(self):
+        self.assertNotEqual(recall._tag_filter_sig(["memory_type:rule"], "any", None, {}), "")
+
+    def test_tag_groups_alone_produce_nonempty_sig(self):
+        groups = [{"op": "all", "tags": ["a", "b"]}]
+        self.assertNotEqual(recall._tag_filter_sig(None, "any", groups, {}), "")
+
+    def test_bank_filters_alone_produce_nonempty_sig(self):
+        filters = {"profile-bank": {"recallTags": ["memory_type:rule"]}}
+        self.assertNotEqual(recall._tag_filter_sig(None, None, None, filters), "")
+
+    def test_sig_is_deterministic(self):
+        a = recall._tag_filter_sig(["t1"], "all", None, {"b": {"recallTags": ["x"]}})
+        b = recall._tag_filter_sig(["t1"], "all", None, {"b": {"recallTags": ["x"]}})
+        self.assertEqual(a, b)
+
+    def test_sig_stable_across_dict_key_order(self):
+        f1 = {"a": {"recallTags": ["x"]}, "b": {"recallTags": ["y"]}}
+        f2 = {"b": {"recallTags": ["y"]}, "a": {"recallTags": ["x"]}}
+        self.assertEqual(
+            recall._tag_filter_sig(["t"], "any", None, f1),
+            recall._tag_filter_sig(["t"], "any", None, f2),
+        )
+
+    def test_different_tags_different_sig(self):
+        self.assertNotEqual(
+            recall._tag_filter_sig(["memory_type:rule"], "any", None, {}),
+            recall._tag_filter_sig(["memory_type:fact"], "any", None, {}),
+        )
+
+    def test_different_match_mode_different_sig(self):
+        self.assertNotEqual(
+            recall._tag_filter_sig(["t"], "any", None, {}),
+            recall._tag_filter_sig(["t"], "all_strict", None, {}),
+        )
+
+    def test_unserializable_falls_back_to_repr(self):
+        # A pathological config value must not raise; it still yields a
+        # non-empty signature distinguishing it from "no filters".
+        sig = recall._tag_filter_sig([object()], "any", None, {})
+        self.assertTrue(sig)
+
+
+class CacheKeyTagFilterTests(unittest.TestCase):
+    """The tag-filter fingerprint must be part of the recall cache key."""
+
+    ARGS = ("s1", "what are the rules", "clerk", ["profile"], "42", "ken")
+
+    def test_no_filters_matches_legacy_key(self):
+        # Default arg == explicit "" — pre-feature cache keys are unchanged.
+        legacy = recall._cache_key(*self.ARGS)
+        explicit = recall._cache_key(*self.ARGS, "")
+        self.assertEqual(legacy, explicit)
+
+    def test_filters_change_the_key(self):
+        sig = recall._tag_filter_sig(["memory_type:rule"], "any", None, {})
+        self.assertNotEqual(recall._cache_key(*self.ARGS), recall._cache_key(*self.ARGS, sig))
+
+    def test_different_filters_different_keys(self):
+        sig_a = recall._tag_filter_sig(["memory_type:rule"], "any", None, {})
+        sig_b = recall._tag_filter_sig(["memory_type:fact"], "any", None, {})
+        self.assertNotEqual(recall._cache_key(*self.ARGS, sig_a), recall._cache_key(*self.ARGS, sig_b))
+
+    def test_per_bank_filter_change_changes_key(self):
+        # Editing only recallAdditionalBankFilters (e.g. for a sender bank)
+        # must also invalidate the cache.
+        sig_a = recall._tag_filter_sig(["t"], "any", None, {"profile": {"recallTags": ["x"]}})
+        sig_b = recall._tag_filter_sig(["t"], "any", None, {"profile": {"recallTags": ["y"]}})
+        self.assertNotEqual(recall._cache_key(*self.ARGS, sig_a), recall._cache_key(*self.ARGS, sig_b))
+
+    def test_same_filters_same_key(self):
+        sig1 = recall._tag_filter_sig(["t"], "all", None, {})
+        sig2 = recall._tag_filter_sig(["t"], "all", None, {})
+        self.assertEqual(recall._cache_key(*self.ARGS, sig1), recall._cache_key(*self.ARGS, sig2))
+
+
+if __name__ == "__main__":
+    unittest.main()