From 0d1810308022cdc07151e4e2cff384f29d9e9942 Mon Sep 17 00:00:00 2001 From: zlareb1 Date: Thu, 19 Nov 2026 03:41:48 +0000 Subject: [PATCH 1/3] Request full graph fields in the caller walkthrough Signed-off-by: zlareb1 --- docs/use-cases/code-intelligence.md | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/docs/use-cases/code-intelligence.md b/docs/use-cases/code-intelligence.md index 0e2e48755f..427644b5ca 100644 --- a/docs/use-cases/code-intelligence.md +++ b/docs/use-cases/code-intelligence.md @@ -74,8 +74,9 @@ successful lookup is not a measurement of task accuracy or cost savings. See ## Check one caller and its impact -Use the same indexed repository and choose a function with one direct caller you can -identify in source. Its language needs call edges +This check is independent of the fast-tier definition check above: the caller may come +from either the fast tier or a compiler tier. Use an indexed repository and choose a +function with one direct caller you can identify in source. Its language needs call edges ([language support](../features/code-index/overview.md#language-support)). Replace the placeholders below with your organization, indexed namespace and qualified function name. @@ -94,18 +95,23 @@ placeholders below with your organization, indexed namespace and qualified funct "name": "", "depth": 1, "max_nodes": 20, - "include_ambiguous": false + "include_ambiguous": false, + "explain": true } } ``` + The inner `arguments.explain: true` requests the full code-op result instead of the + compact MCP shape, which can omit fields needed for these checks. It does not change graph + coverage or freshness. + Check a returned `edges` row's `from_symbol`, `path`, `line`, `edge_kind`, `tier` and `confidence`. Verify that the source at that tier's recorded commit contains the direct call; a reference to the name alone does not establish a call. If `ambiguous` is true, choose the intended qualified name from `candidates` first. 3. Call `loom_op` again with `op: "code.impact"` and - `arguments: {"org": "", "namespace": "", "name": "", "depth": 1, "per_hop_limit": 20}`. + `arguments: {"org": "", "namespace": "", "name": "", "depth": 1, "per_hop_limit": 20, "explain": true}`. Look for the checked caller in `impacted_symbols`: `qualified_name`, `path`, `hop: 1` and `tier`. This request resolves the supplied name; `files` would seed every function in those files. `impacted_tests` lists mapped tests; From 1607d686245c55822c49b3ea9b7bc16efe7a63ea Mon Sep 17 00:00:00 2001 From: zlareb1 Date: Fri, 20 Nov 2026 20:52:44 +0000 Subject: [PATCH 2/3] Name the code search and caller graph page intent Signed-off-by: zlareb1 --- docs/use-cases/code-intelligence.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/docs/use-cases/code-intelligence.md b/docs/use-cases/code-intelligence.md index 427644b5ca..fc6f6da66e 100644 --- a/docs/use-cases/code-intelligence.md +++ b/docs/use-cases/code-intelligence.md @@ -1,3 +1,8 @@ +--- +title: MCP code search and caller graphs for coding agents +description: Search indexed repositories over MCP, inspect definitions and callers, check tier-specific commits and follow code-linked lessons before changing code. +--- + # A code index for coding agents Loom gives coding agents a shared index of your git repositories, served over MCP, so an From 96be03c3d5fa4062c8ca44226a5e138642c86504 Mon Sep 17 00:00:00 2001 From: zlareb1 Date: Fri, 20 Nov 2026 21:40:07 +0000 Subject: [PATCH 3/3] Replicated erasure fixtures provide isolated write leases Fenced memory inserts require a lease table in the selected schema. Give each fixture database its own Keeper root while preserving the replicated content checks. Signed-off-by: zlareb1 --- .../integration/test_erasure_replicated_ch.py | 5 + tests/unit/test_erasure_replicated_fixture.py | 96 +++++++++++++++++++ 2 files changed, 101 insertions(+) create mode 100644 tests/unit/test_erasure_replicated_fixture.py diff --git a/tests/integration/test_erasure_replicated_ch.py b/tests/integration/test_erasure_replicated_ch.py index a1fa3f60c9..611f07969d 100644 --- a/tests/integration/test_erasure_replicated_ch.py +++ b/tests/integration/test_erasure_replicated_ch.py @@ -74,6 +74,11 @@ def db(raw: Any, monkeypatch: pytest.MonkeyPatch) -> Iterator[str]: parameters={"db": name}, ).result_rows assert engines == [(True,)] + # Fenced memory inserts need leases isolated from the source schema's keys. + raw.command( + f"CREATE TABLE {name}._migration_lock AS {source}._migration_lock " + f"ENGINE = KeeperMap('/{name}/_migration_lock') PRIMARY KEY name" + ) monkeypatch.setattr(settings, "ch_database", name) yield name finally: diff --git a/tests/unit/test_erasure_replicated_fixture.py b/tests/unit/test_erasure_replicated_fixture.py new file mode 100644 index 0000000000..3147871591 --- /dev/null +++ b/tests/unit/test_erasure_replicated_fixture.py @@ -0,0 +1,96 @@ +"""The replicated erasure fixture supplies an isolated write-lease store.""" + +from __future__ import annotations + +from types import SimpleNamespace + +import pytest + +from server.core import leases +from server.settings import settings +from tests.integration import test_erasure_replicated_ch as replicated +from tests.unit.claims_fake import FakeLockTable + + +class Schema: + def __init__(self): + self.tables = {} + self.commands = [] + + def command(self, sql): + self.commands.append(sql) + if sql.startswith("CREATE TABLE "): + self.tables[sql.split()[2]] = sql + + def query(self, sql, parameters=None): + if "engine_full" in sql: + assert parameters["db"] == "source_schema" + return SimpleNamespace(result_rows=[("ReplacingMergeTree(version) ORDER BY tuple()",)]) + assert "SELECT DISTINCT engine" in sql + flags = {"ENGINE = Replicated" in ddl for ddl in self.tables.values()} + return SimpleNamespace(result_rows=[(flag,) for flag in sorted(flags)]) + + +class FixtureLocks(FakeLockTable): + def __init__(self, schema): + super().__init__() + self.schema = schema + + async def query_one(self, sql, params=None): + if "loom._migration_lock" in sql: + if f"{settings.ch_database}._migration_lock" not in self.schema.tables: + raise RuntimeError("Unknown table _migration_lock") + return await super().query_one(sql, params) + + +@pytest.fixture +def isolated_schema(monkeypatch): + monkeypatch.setattr(settings, "ch_database", "source_schema") + schema = Schema() + stream = replicated.db.__wrapped__(schema, monkeypatch) + name = next(stream) + try: + yield schema, name + finally: + stream.close() + assert schema.commands[-1] == f"DROP DATABASE IF EXISTS {name} SYNC" + + +async def test_replicated_erasure_fixture_can_take_and_release_a_write_lease(isolated_schema): + schema, name = isolated_schema + keeper = FixtureLocks(schema) + lease = await leases.take("memory_insert/fixture", ttl_s=60, ch=keeper) + assert lease is not None and lease.held + assert settings.ch_database == name + await lease.release() + assert keeper.keys == {} + + +async def test_a_missing_fixture_lease_table_still_refuses(isolated_schema): + schema, name = isolated_schema + schema.tables.pop(f"{name}._migration_lock", None) + with pytest.raises(leases.LeaseUnavailable): + await leases.take("memory_insert/fixture", ttl_s=60, ch=FixtureLocks(schema)) + + +def test_fixture_lease_paths_are_separate_from_source_and_each_other(monkeypatch): + paths = [] + for _ in range(2): + with monkeypatch.context() as patch: + patch.setattr(settings, "ch_database", "source_schema") + schema = Schema() + stream = replicated.db.__wrapped__(schema, patch) + name = next(stream) + try: + ddl = schema.tables[f"{name}._migration_lock"] + assert "AS source_schema._migration_lock" in ddl + assert f"KeeperMap('/{name}/_migration_lock')" in ddl + assert "PRIMARY KEY name" in ddl + assert all( + "ENGINE = Replicated" in schema.tables[f"{name}.{table}"] + for table in replicated._TABLES + ) + paths.append(name) + finally: + stream.close() + assert paths[0] != paths[1]