# -*- coding: utf-8 -*- """scene="all"（search / list）与生产力条目的 update / delete。 客户端用 object.__new__(HyMemoryClient) 搭最小骨架，公开 async_* 方法通过 __wrapped__ 直接调（不需要 client 自己的 loop 线程），与 test_list_and_stats_by_scene.py 同一套写法。 """ from datetime import datetime, timedelta, timezone from types import SimpleNamespace import pytest from hy_memory.client import _SCENE_RRF_K, HyMemoryClient from hy_memory.coding.store import CodingMemoryStore from hy_memory.coding.types import CodingMemory, WorkingFact from hy_memory.models.memory import MemoryLayer, MemoryStatus from hy_memory.retrieval import AmbiguousMemoryIdError BASE = datetime(2026, 10, 20, 8, 0, 0) def _unwrapped(name): return getattr(HyMemoryClient, name).__wrapped__ async def _store(coding_config, mock_embed, variant): store = CodingMemoryStore(coding_config, embed_service=mock_embed, variant=variant) await store.initialize() return store async def _noop(*_args, **_kwargs): return None def _client(coding_config, mock_embed, stores, *, nodes=()): client = object.__new__(HyMemoryClient) client._config = coding_config client._coding_stores = dict(stores) client._embed_service = mock_embed client._cache = None client._graph_store = None client._history_store = None client._vector_store = _FakeVectorStore(list(nodes)) client._get_coding_writer = _noop client._maybe_store_op_log = _noop client._decorate_with_chain = lambda *a, **k: ("", []) return client class _FakeVectorStore: def __init__(self, nodes): self.nodes = {n.node_id: n for n in nodes} async def list_by_user(self, *, layers=None, **_): if layers == [MemoryLayer.L0_BASIC_INFO]: return [] return list(self.nodes.values()) async def get_by_id(self, memory_id): return self.nodes.get(memory_id) def _chat_node(node_id, *, created, modified=None, source="cursor"): return SimpleNamespace( node_id=node_id, layer=MemoryLayer.L2_FACT, status=MemoryStatus.ACTIVE, content=f"chat {node_id}", memory_at=None, gmt_created=created, gmt_modified=modified, valid_from=None, user_id="u", agent_id="a", session_id="s", source=source, speculate=None, tags=[], custom={}, ) # ================================================================ # search(scene="all") # ================================================================ def _chat_resp(*ids): return { "request_id": "r", "memories": { "normal": [ {"memory_id": i, "content": f"chat {i}", "score": 0.9 - n * 0.1, "gmt_created": 1_700_000_000 + n, "source": "cursor"} for n, i in enumerate(ids) ], "schema": [], "proactive": [], }, } def _prod_resp(facts=(), exps=()): return { "request_id": "r", "scene": "productivity", "facts": [ {"fact_id": f, "statement": f"stmt {f}", "score": 0.5, "created_at": "2026-10-20T08:00:00", "source": "claude"} for f in facts ], "experiences": [ {"experience_id": e, "task": f"task {e}", "solution": f"sol {e}", "score": 0.7, "updated_at": "2026-10-20T09:00:00", "source": "claude"} for e in exps ], } def _fake_all_client(*, chat, working=None, coding=None, fail=(), enable=True, seen=None): """_search_all_scenes 的依赖全部换成桩：只测融合与容错。""" client = object.__new__(HyMemoryClient) client._config = SimpleNamespace(coding=SimpleNamespace(enable=enable)) class _Embed: calls = 0 async def embed(self, text): _Embed.calls += 1 return [0.1, 0.2] client._embed_service = _Embed() seen = seen if seen is not None else {} async def _impl(query, **kw): seen["chat"] = kw if "chat" in fail: raise RuntimeError("chat backend down") return chat async def _coding_store(variant): return object() if {"working": working, "coding": coding}[variant] is not None else None async def _search_coding(target_query, **kw): seen[kw["variant"]] = kw if kw["variant"] in fail: raise RuntimeError(f"{kw['variant']} store broken") return {"working": working, "coding": coding}[kw["variant"]] client._async_search_impl = _impl client._coding_store_for_exact_get = _coding_store client._search_coding = _search_coding return client, seen async def _search_all(client, **kw): params = dict( queries=None, search_mode="default", user_ids=["u"], agent_ids=[], session_ids=[], include_sources=["claude"], exclude_sources=["mixed"], limit=10, min_score=0.4, working_fact_min_score=None, working_experience_min_score=None, schema_min_score=0.4, schema_limit=10, intention_limit=0, created_after=None, reader="", workspace_id=None, branch=None, request_id="req", layers=None, query_embedding=None, rerank=True, target_query="q", lite_mode=False, t0=0.0, ) params.update(kw) return await HyMemoryClient._search_all_scenes(client, "q", **params) async def test_search_all_fuses_by_lane_rank_with_rrf(): client, seen = _fake_all_client( chat=_chat_resp("c1", "c2", "c3"), working=_prod_resp(facts=["wf1"], exps=["we1", "we2"]), coding=_prod_resp(exps=["ce1"]), ) out = await _search_all(client, rerank=False) assert out["scene"] == "all" assert out["request_id"] == "req" assert out["lanes"] == {"chat": 3, "working": 3, "coding": 1} assert out["errors"] == {} order = [(m["scene"], m["memory_id"]) for m in out["memories"]] # 名次 1：chat → working → coding（同分按路序），名次 2：chat / working ... assert order == [ ("chat", "c1"), ("working", "wf1"), ("coding", "ce1"), ("chat", "c2"), ("working", "we1"), ("chat", "c3"), ("working", "we2"), ] first = out["memories"][0] assert first["score"] == round(1.0 / (_SCENE_RRF_K + 1), 6) assert first["lane_score"] == pytest.approx(0.9) assert first["lane_rank"] == 1 and first["kind"] == "chat" fact = out["memories"][1] assert fact["kind"] == "fact" and fact["content"] == "stmt wf1" assert fact["lane_score"] == 0.5 exp = out["memories"][4] assert exp["kind"] == "experience" assert exp["memory_id"] == "we1" assert exp["content"] == "task we1\nsol we1" assert exp["score"] == round(1.0 / (_SCENE_RRF_K + 2), 6) # 生产力时间戳是 naive UTC，按 UTC 换算成 epoch assert exp["updated_at"] == int( datetime(2026, 10, 20, 9, tzinfo=timezone.utc).timestamp() ) # rerank / 来源过滤 / 阈值传到每一路，query 向量只算一次 for lane in ("chat", "working", "coding"): assert seen[lane]["rerank"] is False assert seen[lane]["include_sources"] == ["claude"] assert seen[lane]["query_embedding"] == [0.1, 0.2] assert seen["chat"]["scene"] == "chat" assert client._embed_service.calls == 1 async def test_search_all_truncates_after_fusion(): client, _ = _fake_all_client( chat=_chat_resp("c1", "c2", "c3"), working=_prod_resp(exps=["we1", "we2"]), coding=None, ) out = await _search_all(client, limit=3) assert [m["memory_id"] for m in out["memories"]] == ["c1", "we1", "c2"] # coding 没写过：不贡献、不算错误 assert out["lanes"]["coding"] == 0 assert "coding" not in out["errors"] async def test_search_all_isolates_a_failing_lane(): client, _ = _fake_all_client( chat=_chat_resp("c1"), working=_prod_resp(exps=["we1"]), coding=_prod_resp(exps=["ce1"]), fail=("working",), ) out = await _search_all(client) assert [m["memory_id"] for m in out["memories"]] == ["c1", "ce1"] assert out["lanes"] == {"chat": 1, "working": 0, "coding": 1} assert "store broken" in out["errors"]["working"] client, _ = _fake_all_client( chat=_chat_resp("c1"), working=_prod_resp(exps=["we1"]), fail=("chat",), ) out = await _search_all(client) assert [m["memory_id"] for m in out["memories"]] == ["we1"] assert "chat backend down" in out["errors"]["chat"] async def test_search_all_reports_disabled_productivity(): client, seen = _fake_all_client( chat=_chat_resp("c1"), working=_prod_resp(exps=["we1"]), enable=False, ) out = await _search_all(client) assert [m["memory_id"] for m in out["memories"]] == ["c1"] assert out["lanes"] == {"chat": 1, "working": 0, "coding": 0} assert set(out["errors"]) == {"working", "coding"} assert "working" not in seen async def test_async_search_routes_scene_all(coding_config): seen = {} async def _spy(query, **kw): seen.update(kw) return {"scene": "all"} client = object.__new__(HyMemoryClient) client._config = coding_config client._search_all_scenes = _spy out = await _unwrapped("async_search")( client, "q", scene=" ALL ", user_ids=["u"], include_sources=["Claude"], rerank=False, limit=7, ) assert out == {"scene": "all"} assert seen["rerank"] is False and seen["limit"] == 7 assert seen["include_sources"] == ["claude"] assert seen["exclude_sources"] == ["mixed"] with pytest.raises(ValueError, match="all"): await _unwrapped("async_search")(client, "q", scene="every", user_ids=["u"]) async def test_search_all_productivity_lanes_respect_sources(coding_config, mock_embed): """真 store：两路生产力检索按 source 过滤，经验与事实都过。""" coding_config.coding.enable = True working = await _store(coding_config, mock_embed, "working") coding = await _store(coding_config, mock_embed, "coding") try: await working.insert(CodingMemory( experience_id="w-claude", user_id="u", task="deploy service", solution="kubectl apply", source="claude", )) await working.insert(CodingMemory( experience_id="w-cursor", user_id="u", task="deploy service", solution="helm upgrade", source="cursor", )) await working.insert_fact(WorkingFact( fact_id="f-cursor", user_id="u", statement="deploy service", source="cursor", )) await coding.insert(CodingMemory( experience_id="c-claude", user_id="u", task="deploy service", solution="make deploy", source="claude", )) client = _client(coding_config, mock_embed, {"working": working, "coding": coding}) async def _chat(query, **kw): return _chat_resp() client._async_search_impl = _chat out = await _search_all( client, target_query="deploy service", include_sources=["claude"], exclude_sources=["mixed"], ) ids = {(m["scene"], m["memory_id"]) for m in out["memories"]} assert ids == {("working", "w-claude"), ("coding", "c-claude")} assert all(m["source"] == "claude" for m in out["memories"]) finally: await working.close() await coding.close() async def test_productivity_search_rerank_false_skips_fact_lexical_rerank( coding_config, mock_embed, monkeypatch, ): from hy_memory.coding import lexical calls = [] real = lexical.rerank def _spy(*args, **kwargs): calls.append(args) return real(*args, **kwargs) monkeypatch.setattr(lexical, "rerank", _spy) working = await _store(coding_config, mock_embed, "working") try: for index in range(8): await working.insert_fact(WorkingFact( fact_id=f"f{index}", user_id="u", statement="deploy service", )) client = _client(coding_config, mock_embed, {"working": working}) async def _run(rerank): return await HyMemoryClient._search_coding( client, "deploy service", user_ids=["u"], workspace_id=None, branch=None, limit=2, request_id="r", t0=0.0, variant="working", rerank=rerank, ) await _run(False) assert calls == [] await _run(True) assert len(calls) == 1 finally: await working.close() # ================================================================ # list_memories(scene="all") 与生产力 list 的来源过滤 # ================================================================ async def test_list_productivity_scene_filters_sources_with_true_total( coding_config, mock_embed, ): coding = await _store(coding_config, mock_embed, "coding") try: for index, source in enumerate(["claude", "cursor", "claude", "Claude"]): await coding.insert(CodingMemory( experience_id=f"c{index}", user_id="u", task="T", solution="S", source=source, )) client = _client(coding_config, mock_embed, {"coding": coding}) list_memories = _unwrapped("async_list_memories") page = await list_memories( client, user_id="u", scene="coding", include_sources=["CLAUDE"], limit=2, ) assert page["total"] == 3 assert len(page["experiences"]) == 2 assert all(e["source"] == "claude" for e in page["experiences"]) page = await list_memories( client, user_id="u", scene="coding", exclude_sources=["claude"], ) assert page["total"] == 1 assert [e["experience_id"] for e in page["experiences"]] == ["c1"] unfiltered = await list_memories(client, user_id="u", scene="coding") assert unfiltered["total"] == 4 finally: await coding.close() async def _seed_all(coding_config, mock_embed): coding = await _store(coding_config, mock_embed, "coding") working = await _store(coding_config, mock_embed, "working") # 生产力时间戳按 UTC 写；这里直接给 updated_at 再改回去（insert 会刷新） for eid, hours, source in (("c-old", 1, "claude"), ("c-new", 5, "cursor")): await coding.insert(CodingMemory( experience_id=eid, user_id="u", task=f"task {eid}", solution="S", source=source, )) await _set_updated(coding, eid, BASE + timedelta(hours=hours)) await working.insert(CodingMemory( experience_id="w-mid", user_id="u", task="task w", solution="W", source="claude", )) await _set_updated(working, "w-mid", BASE + timedelta(hours=3)) # chat 节点是本地时间 naive；与 UTC 的经验比较时要换算到同一 epoch utc_offset = datetime.now() - datetime.utcnow() nodes = [ _chat_node("m-newest", created=BASE + utc_offset + timedelta(hours=6), source="claude"), _chat_node("m-edited", created=BASE + utc_offset, modified=BASE + utc_offset + timedelta(hours=4), source="cursor"), _chat_node("m-oldest", created=BASE + utc_offset, source="claude"), ] return coding, working, nodes async def _set_updated(store, experience_id, when): def _sync(): with store._lock: store._conn.execute( "UPDATE coding_memory_meta SET updated_at = ? WHERE experience_id = ?", (when.isoformat(), experience_id), ) _sync() async def test_list_all_merges_newest_first_and_paginates(coding_config, mock_embed): coding, working, nodes = await _seed_all(coding_config, mock_embed) try: client = _client(coding_config, mock_embed, {"coding": coding, "working": working}, nodes=nodes) list_memories = _unwrapped("async_list_memories") out = await list_memories(client, user_id="u", scene="all", limit=10) assert out["scene"] == "all" assert out["total"] == 6 assert out["totals"] == {"chat": 3, "working": 1, "coding": 2} assert [(m["scene"], m["memory_id"]) for m in out["memories"]] == [ ("chat", "m-newest"), ("coding", "c-new"), ("chat", "m-edited"), ("working", "w-mid"), ("coding", "c-old"), ("chat", "m-oldest"), ] exp = out["memories"][1] assert exp["kind"] == "experience" and exp["content"] == "task c-new\nS" assert exp["status"] == "active" assert exp["updated_at"] > out["memories"][2]["updated_at"] assert out["memories"][0]["kind"] == "chat" pages = [] for offset in (0, 2, 4): page = await list_memories( client, user_id="u", scene="all", limit=2, offset=offset, ) assert page["total"] == 6 pages.extend(m["memory_id"] for m in page["memories"]) assert pages == [m["memory_id"] for m in out["memories"]] with pytest.raises(ValueError, match="desc"): await list_memories(client, user_id="u", scene="all", order="asc") finally: await coding.close() await working.close() async def test_list_all_applies_source_and_status_filters(coding_config, mock_embed): coding, working, nodes = await _seed_all(coding_config, mock_embed) try: client = _client(coding_config, mock_embed, {"coding": coding, "working": working}, nodes=nodes) list_memories = _unwrapped("async_list_memories") out = await list_memories( client, user_id="u", scene="all", include_sources=["claude"], ) assert [m["memory_id"] for m in out["memories"]] == [ "m-newest", "w-mid", "c-old", "m-oldest", ] assert out["totals"] == {"chat": 2, "working": 1, "coding": 1} assert out["total"] == 4 out = await list_memories( client, user_id="u", scene="all", statuses=["archived"], ) # 经验只有 ACTIVE：两路生产力不贡献；chat 假库不按状态过滤，原样返回 assert out["totals"]["working"] == 0 and out["totals"]["coding"] == 0 assert all(m["scene"] == "chat" for m in out["memories"]) finally: await coding.close() await working.close() async def test_list_all_does_not_create_unwritten_scene_databases(coding_config, mock_embed): client = _client(coding_config, mock_embed, {}, nodes=[ _chat_node("m1", created=BASE), ]) out = await _unwrapped("async_list_memories")(client, user_id="u", scene="all") assert out["total"] == 1 assert out["totals"] == {"chat": 1, "working": 0, "coding": 0} for variant in ("working", "coding"): assert not CodingMemoryStore.database_exists( coding_config, db_path=coding_config.coding.db_path, variant=variant, ) # ================================================================ # update / delete 生产力条目 # ================================================================ async def test_update_experience_replaces_solution_and_keeps_task(coding_config, mock_embed): working = await _store(coding_config, mock_embed, "working") try: await working.insert(CodingMemory( experience_id="e1", user_id="u", task="deploy service", search_keys=["rollout"], solution="old way", )) await _set_updated(working, "e1", BASE) client = _client(coding_config, mock_embed, {"working": working}) out = await _unwrapped("async_update")(client, "e1", "new way") assert out["success"] is True assert out["memory_id"] == "e1" assert out["kind"] == "experience" and out["variant"] == "working" assert {"request_id", "elapsed_ms"} <= set(out) stored = await working.get_by_id("e1") assert stored.task == "deploy service" assert stored.solution == "new way" assert stored.updated_at > BASE # solution 不进向量：仍能按原 task 召回 hits = await working.search_by_query_embedding( await mock_embed.embed("deploy service"), user_id="u", ) assert hits and hits[0]["experience_id"] == "e1" out = await _unwrapped("async_update")( client, "e1", "newer way", task="ship service", ) assert out["success"] is True stored = await working.get_by_id("e1") assert stored.task == "ship service" hits = await working.search_by_query_embedding( await mock_embed.embed("ship service"), user_id="u", ) assert hits[0]["experience_id"] == "e1" assert hits[0]["score"] == pytest.approx(1.0, abs=1e-4) finally: await working.close() async def test_update_and_delete_fact(coding_config, mock_embed): coding = await _store(coding_config, mock_embed, "coding") try: await coding.insert_fact(WorkingFact( fact_id="f1", user_id="u", statement="build uses make", )) client = _client(coding_config, mock_embed, {"coding": coding}) out = await _unwrapped("async_update")( client, "f1", "build uses bazel", kind="fact", ) assert out["success"] is True and out["variant"] == "coding" assert (await coding.get_fact("f1")).statement == "build uses bazel" hits = await coding.search_facts( await mock_embed.embed("build uses bazel"), user_id="u", ) assert [f.fact_id for f, _ in hits] == ["f1"] with pytest.raises(ValueError, match="task"): await _unwrapped("async_update")(client, "f1", "x", task="t") out = await _unwrapped("async_delete")(client, "f1") assert out["success"] is True and out["deleted_count"] == 1 assert out["kind"] == "fact" assert await coding.get_fact("f1") is None assert await coding.search_facts( await mock_embed.embed("build uses bazel"), user_id="u", ) == [] finally: await coding.close() async def test_delete_experience_removes_row_and_vectors(coding_config, mock_embed): working = await _store(coding_config, mock_embed, "working") try: await working.insert(CodingMemory( experience_id="e1", user_id="u", task="deploy service", search_keys=["rollout"], solution="S", )) client = _client(coding_config, mock_embed, {"working": working}) out = await _unwrapped("async_delete")( client, "e1", kind="experience", variant="working", ) assert out["success"] is True assert out["deleted_count"] == 1 assert out["memory_id"] == "e1" assert await working.get_by_id("e1") is None assert await working._vec.get_by_id("e1:0") is None assert await working._vec.get_by_id("e1:1") is None finally: await working.close() async def test_productivity_not_found_and_ambiguity(coding_config, mock_embed): working = await _store(coding_config, mock_embed, "working") coding = await _store(coding_config, mock_embed, "coding") try: for store in (working, coding): await store.insert(CodingMemory( experience_id="same", user_id="u", task="T", solution="S", )) client = _client(coding_config, mock_embed, {"working": working, "coding": coding}) with pytest.raises(AmbiguousMemoryIdError): await _unwrapped("async_update")(client, "same", "x") with pytest.raises(AmbiguousMemoryIdError): await _unwrapped("async_delete")(client, "same") out = await _unwrapped("async_delete")(client, "same", variant="coding") assert out["success"] is True and out["variant"] == "coding" assert await working.get_by_id("same") is not None missing = await _unwrapped("async_update")(client, "nope", "x", kind="experience") assert missing["success"] is False and "not found" in missing["error_message"] missing = await _unwrapped("async_delete")(client, "nope", kind="fact") assert missing["success"] is False and missing["deleted_count"] == 0 # variant 给了就不回落到 chat missing = await _unwrapped("async_delete")(client, "nope", variant="working") assert missing["success"] is False and missing["deleted_count"] == 0 with pytest.raises(ValueError): await _unwrapped("async_delete")(client, "same", kind="chat", variant="coding") finally: await working.close() await coding.close() async def test_update_and_delete_without_kind_still_handle_chat(coding_config, mock_embed): """默认行为不变：chat ID 走原 chat 路径（store 都没建时也不建库）。""" client = _client(coding_config, mock_embed, {}) seen = [] async def _chat_update(memory_id, content): seen.append(("update", memory_id, content)) return {"success": True, "memory_id": memory_id} async def _chat_delete(memory_id): seen.append(("delete", memory_id)) return {"success": True, "deleted_count": 1} client._update_chat = _chat_update client._delete_chat = _chat_delete client._vector_store = _FakeVectorStore([_chat_node("m1", created=BASE)]) assert (await _unwrapped("async_update")(client, "m1", "new"))["success"] assert (await _unwrapped("async_delete")(client, "m1"))["success"] # 哪都没有：仍交给 chat 路径给出原来的 not-found 结果 await _unwrapped("async_delete")(client, "ghost") assert seen == [("update", "m1", "new"), ("delete", "m1"), ("delete", "ghost")] for variant in ("working", "coding"): assert not CodingMemoryStore.database_exists( coding_config, db_path=coding_config.coding.db_path, variant=variant, )