webbee 0.7.2__tar.gz → 0.7.3__tar.gz

{webbee-0.7.2 → webbee-0.7.3}/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.7.3
+
+* **A folder of repositories is a folder** (second 06.11 report).
+  * Repositories nested deeper (`core/<repo>`, `modules/<repo>`) are found, up to four levels.
+  * Each repository syncs on its own, even when the folder's top holds loose scripts or a manifest. Before, the
+    whole folder was one 670-file project.
+  * Imports are resolved inside each repository first; a package another repository provides is linked to it.
+* **The cloud graph answers from the first minute.**
+  * While the session's first sync runs, the vault answers with the keys it confirmed last time, and the answer
+    says so.
+  * "pending" ends with that first run. Before, every tool call queued a sync and the kernel always met one running.
+* **Facts, not names.**
+  * The `read_file` header lists only the files whose references resolve to the file (it said "used by
+    check-paths-agree.py, +50 more").
+  * `graph_slice` callers are the real calls, with line and caller.
+  * `impact_of_change` says in one sentence what it found, including name-only matches as unproven.
+* Python members resolve through typed locals, `self` attributes and return annotations.
+* Needs imperal-mcp 0.9.3 and imperal-sdk 6.5.1.
+
 ## 0.7.2
 
 * **The code graph answers correctly** (06.11 report):

{webbee-0.7.2 → webbee-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: webbee
-Version: 0.7.2
+Version: 0.7.3
 Summary: Webbee 🐝 — the Imperal Cloud coding agent in your terminal
 Project-URL: Homepage, https://imperal.io
 Project-URL: Documentation, https://docs.imperal.io
@@ -31,8 +31,8 @@ Requires-Python: >=3.7
 Requires-Dist: asyncssh>=2.14; python_version >= '3.10'
 Requires-Dist: httpx-sse>=0.4; python_version >= '3.10'
 Requires-Dist: httpx>=0.27; python_version >= '3.10'
-Requires-Dist: imperal-mcp>=0.9.2; python_version >= '3.10'
-Requires-Dist: imperal-sdk[universal-index]>=6.5.0; python_version >= '3.10'
+Requires-Dist: imperal-mcp>=0.9.3; python_version >= '3.10'
+Requires-Dist: imperal-sdk[universal-index]>=6.5.1; python_version >= '3.10'
 Requires-Dist: model2vec>=0.8.2; python_version >= '3.10' and (sys_platform != 'darwin' or platform_machine != 'x86_64' or python_version < '3.13')
 Requires-Dist: numpy>=2; python_version >= '3.10' and (sys_platform != 'darwin' or platform_machine != 'x86_64' or python_version < '3.13')
 Requires-Dist: prompt-toolkit>=3; python_version >= '3.10'

{webbee-0.7.2 → webbee-0.7.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "webbee"
-version = "0.7.2"
+version = "0.7.3"
 description = "Webbee 🐝 — the Imperal Cloud coding agent in your terminal"
 readme = "README.md"
 license = "GPL-3.0-or-later"
@@ -13,8 +13,8 @@ dependencies = [
     # release on a Python 3.12 it sets up once with uv -- `uv` comes as a wheel on 3.8+,
     # 3.7 fetches it with uv's own installer.
     'uv>=0.4; python_version >= "3.8" and python_version < "3.10"',
-    'imperal-mcp>=0.9.2; python_version >= "3.10"',   # raised to the newest at each release
-    'imperal-sdk[universal-index]>=6.5.0; python_version >= "3.10"',
+    'imperal-mcp>=0.9.3; python_version >= "3.10"',   # raised to the newest at each release
+    'imperal-sdk[universal-index]>=6.5.1; python_version >= "3.10"',
     'asyncssh>=2.14; python_version >= "3.10"',
     'httpx>=0.27; python_version >= "3.10"',
     'httpx-sse>=0.4; python_version >= "3.10"',

webbee-0.7.3/src/webbee/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.7.3"

{webbee-0.7.2 → webbee-0.7.3}/src/webbee/intel/query.py

@@ -14,22 +14,42 @@ def _sym_item(s) -> dict:
 
 def repo_profile(svc) -> dict:
     p = svc.repo_profile()
-    item = {"id": p["repo_key"], "title": f"repo ({p['file_count']} files)", "kind": "repo", **p}
+    repos = p.get("repos") or []
+    title = (f"folder ({p['file_count']} files, {len(repos)} repositories: {', '.join(repos[:12])}"
+             + (" ..." if len(repos) > 12 else "") + ")") if repos else f"repo ({p['file_count']} files)"
+    item = {"id": p["repo_key"], "title": title, "kind": "folder" if repos else "repo", **p}
     return _env([item])
 
 
 def graph_slice(svc, symbols, depth: int = 1) -> dict:
+    """Each definition a symbol names, with its RESOLVED callers (file, line, the calling definition) and callees
+    (what its body's references resolve to) -- the vault's rules (``imperal_sdk.code_links``). Before, the callers
+    were every definition of every file where the name appeared (report 06.11 #2)."""
     if svc is None or svc.graph is None:
         return {"ok": False, "content": "index not ready"}
     if isinstance(symbols, str):
         symbols = [symbols]
-    g, items = svc.graph, []
+    lk = linker(svc)
+    links = lk.links()
+    items = []
     for name in (symbols or []):
-        for s in g.symbol_table.get(name, []):
-            it = _sym_item(s)
-            it["callers"] = [c.name for c in g.callers_of(name)][:20]
-            it["callees"] = g.callees_of(s)[:20]
+        for path, qual in lk.symbol_targets(str(name)):
+            if not qual:
+                continue
+            d = lk.defs(path).get(qual)
+            it = {"id": f"{path}::{qual}", "title": qual, "kind": getattr(d, "kind", ""),
+                  "subtitle": f"{path}:{getattr(d, 'start_line', 0)}", "signature": getattr(d, "signature", ""),
+                  "path": path, "start_line": getattr(d, "start_line", 0), "end_line": getattr(d, "end_line", 0)}
+            callers = [{"path": src, "user": user or "(module)", "line": line, "kind": kind}
+                       for src, user, kind, line, tp, tq, _o in links
+                       if tp == path and (tq == qual or tq.startswith(qual + ".")) and not (src == path and user == qual)]
+            it["callers"] = callers[:20]
+            it["callers_total"] = len(callers)
+            it["callees"] = sorted({f"{tp}::{tq}" if tq else tp for src, user, _k, _l, tp, tq, _o in links
+                                    if src == path and (user == qual or user.startswith(qual + "."))})[:20]
             items.append(it)
+    if not items:
+        return {**_env([]), "note": f"{', '.join(map(str, symbols or []))}: not a definition in this index"}
     return _env(items)
 
 
@@ -247,7 +267,14 @@ def linker(svc):
         except Exception:
             continue
         configs.append({"path": rel.replace("\\", "/"), "kind": kind, "data": data})
-    lk = Linker(facts, configs)
+    roots = []
+    if root:
+        try:
+            from webbee.intel.service import is_repository, sub_repositories
+            roots = [] if is_repository(root) else sub_repositories(root)
+        except Exception:
+            roots = []
+    lk = Linker(facts, configs, roots)
     svc._linker, svc._linker_graph = lk, g
     return lk
 
@@ -277,6 +304,9 @@ def impact_of_change(svc, symbols) -> dict:
     if extra:
         out["by_name_count"] = int(out.get("by_name_count") or 0) + len(extra)
         out["by_name"] = sorted(out["by_name"] + extra, key=lambda b: (b["group"] == "tests", b["path"]))[:BY_NAME_SHOWN]
+    from imperal_sdk.code_links import impact_summary
+    out["summary"] = impact_summary(syms, out["resolved"], len(out["data"]["items"]), int(out.get("by_name_count") or 0),
+                                    len(out.get("same_file") or []))
     if not out["resolved"]:
         out["note"] = f"{', '.join(syms)}: not a definition in this index"
     out["link"] = "resolved locally (the vault's rules); by_name lists name-only matches apart"

{webbee-0.7.2 → webbee-0.7.3}/src/webbee/intel/service.py

@@ -7,6 +7,7 @@ from __future__ import annotations
 import asyncio
 import hashlib
 import logging
+import json
 import os
 import subprocess
 import sys
@@ -754,9 +755,10 @@ class IntelService:
         if rels is not None:            # a change: only the repositories it touched, with their own paths
             by_repo: dict = {}
             for rel in rels:
-                head, _, tail = str(rel).replace(os.sep, "/").partition("/")
-                if head in subs and tail:
-                    by_repo.setdefault(head, []).append(tail)
+                rel = str(rel).replace(os.sep, "/")
+                head = repo_of(rel, subs)
+                if head and rel != head:
+                    by_repo.setdefault(head, []).append(rel[len(head) + 1:])
             todo = {name: by_repo[name] for name in by_repo}
         else:
             todo = {name: None for name in subs}
@@ -766,6 +768,8 @@ class IntelService:
             if out.get("repo_key"):
                 repos[name] = str(out["repo_key"])
         out = {"repo_key": "", "repos": repos}
+        if repos and rels is None:
+            remember_keys(self.root, out)
         if repos:
             self.last_sync = out
             self.last_sync_ok_at = time.time()
@@ -815,6 +819,8 @@ class IntelService:
                     return out
                 measured = co_change_pairs(root) if rels is None and history else None
                 out = asyncio.run(vault_sync(factory(), meta, listing, read, measured))
+                if out.get("repo_key") and rels is None and os.path.realpath(root) == os.path.realpath(self.root):
+                    remember_keys(root, out)
                 if sig and out.get("repo_key"):
                     self._synced_sigs[root] = (sig, str(out["repo_key"]), time.time())
                 elif rels is not None:
@@ -844,10 +850,16 @@ class IntelService:
         extract + embed, minutes) it answers at once ``{pending}`` -- a state, not a failure. ``wait_s``: tests only."""
         if self.vault_client_factory is None:
             return {"ok": False, "content": "this session cannot reach the cloud"}
-        if not self.last_sync and self._sync_busy():
-            # the repo's first sync (a whole repo: extract + embed) is still running: answered at once, as a state
-            return {"pending": "the first code sync of this workspace is still running -- the local index answers "
-                               "until it ends"}
+        if self._sync_done == 0 and self._sync_busy():
+            # the session's FIRST sync is still running (a whole repo: extract + embed): answered at once, as a state
+            # -- with the keys the vault confirmed for this folder last time, so the cloud graph answers meanwhile
+            # (marked by its age). Only the first run: after it, each answer waits for its own sync (report 06.11 #2:
+            # every tool call queued a sync and every kernel ask met one running -- "pending" for a whole session)
+            known = remembered_keys(self.root)
+            return {"pending": "the first code sync of this workspace is still running -- "
+                               + ("the cloud graph answers from the last confirmed sync"
+                                  if known else "the local index answers until it ends"),
+                    **({"known": known} if known else {})}
         ticket = self._sync_request(None, history=False)
         with self._sync_cv:
             done = self._sync_cv.wait_for(lambda: self._sync_done >= ticket, timeout=wait_s)
@@ -1009,38 +1021,113 @@ class IntelService:
 
 
 SUB_REPOS_MAX = 40     # a folder of projects: at most this many of its repositories are synced
+REPO_DEPTH = 4         # repositories are looked for this deep (~/Projects/<org>/<repo>, a folder's core/<repo>)
+_REPOS_TTL_S = 30.0    # a folder's repositories, remembered this long (is_repository asks on every tool call)
+_REPOS_SEEN: dict = {}
+# a home folder's system trees: never walked for repositories (macOS Library / Applications, Volumes ...)
+_TOP_NEVER = frozenset({"Library", "Applications", "System", "Volumes", "private", "cores", "dev"})
+
+
+def find_repositories(root: str, depth: int = REPO_DEPTH) -> list:
+    """The repositories inside ``root`` (folders holding ``.git``: a directory, or a file in a worktree), as
+    root-relative posix paths, at most ``depth`` levels down -- never under a hidden, skipped or linked folder, never
+    inside another repository (report 06.11 #2: core/wpanel-sdk, modules/wpanel-tickets were one level too deep and
+    the whole folder became one project). The ONE rule for Webbee and imperal-mcp."""
+    key = (os.path.realpath(root), int(depth))
+    hit = _REPOS_SEEN.get(key)
+    if hit and time.monotonic() - hit[0] < _REPOS_TTL_S:
+        return list(hit[1])
+    out: list = []
+    frontier = [""]
+    for _ in range(max(1, int(depth))):
+        nxt: list = []
+        for rel in frontier:
+            here = os.path.join(root, rel) if rel else root
+            try:
+                names = sorted(os.listdir(here))
+            except OSError:
+                continue
+            for name in names:
+                full = os.path.join(here, name)
+                if (not rel and name in _TOP_NEVER) or os.path.islink(full) or not os.path.isdir(full) \
+                        or skipped_dir(here, name):
+                    continue
+                child = f"{rel}/{name}" if rel else name
+                (out if os.path.exists(os.path.join(full, ".git")) else nxt).append(child)
+        frontier = nxt
+    _REPOS_SEEN[key] = (time.monotonic(), tuple(out))
+    return out
 
 
 def sub_repositories(root: str) -> list:
-    """The repositories directly inside a folder that is none itself: sub-folders with ``.git`` (never a link, never a
-    hidden folder; a manifest alone does not make a sub-folder a project here), sorted, bounded."""
-    try:
-        names = sorted(os.listdir(root))
-    except OSError:
-        return []
-    out = []
-    for name in names:
-        full = os.path.join(root, name)
-        if name.startswith(".") or os.path.islink(full) or not os.path.isdir(full):
-            continue
-        try:
-            if ".git" in os.listdir(full):
-                out.append(name)
-        except OSError:
-            continue
-    return out[:SUB_REPOS_MAX]
+    """The repositories inside a folder that is none itself (``find_repositories``), sorted, bounded."""
+    return find_repositories(root)[:SUB_REPOS_MAX]
 
 
 def is_repository(root: str) -> bool:
-    """A repository the code graph may hold: ``.git`` (a dir, or a file in a worktree) or a project manifest at the
-    root. A home folder or a folder of projects is none -- its repositories are synced one by one (owner 2026-10-25)."""
+    """A repository the code graph may hold as ONE: ``.git`` at the root; without it, a folder holding repositories
+    is a folder of them (each synced on its own -- even with a manifest or loose scripts at the top, report 06.11
+    #2); otherwise any ecosystem's manifest makes it a project without version control. A home folder or a folder
+    of projects is none (owner 2026-10-25)."""
     try:
         names = set(os.listdir(root))
     except OSError:
         return False
+    if ".git" in names:
+        return True
+    if find_repositories(root):
+        return False
     return indexer.is_project_root(names)
 
 
+def repo_of(rel: str, repos) -> str:
+    """The repository of a folder-relative path: the longest repository path it lies under, or ""."""
+    rel = str(rel).replace(os.sep, "/").lstrip("./")
+    best = ""
+    for r in repos or ():
+        if (rel == r or rel.startswith(r + "/")) and len(r) > len(best):
+            best = r
+    return best
+
+
+# the vault's keys of the repositories this machine last synced (a new session answers from the cloud graph while
+# its own first sync still runs -- report 06.11 #2: a whole session ran on the local index)
+_KEYS_FILE = os.path.join(os.path.expanduser("~"), ".local", "share", "webbee", "vault-keys.json")
+
+
+def remembered_keys(root: str) -> dict:
+    """``{repo_key | repos, synced_at}`` the vault last confirmed for ``root`` on this machine, or {}."""
+    try:
+        with open(_KEYS_FILE, encoding="utf-8") as f:
+            got = json.load(f).get(os.path.realpath(root)) or {}
+        return got if isinstance(got, dict) and (got.get("repo_key") or got.get("repos")) else {}
+    except (OSError, ValueError, AttributeError):
+        return {}
+
+
+def remember_keys(root: str, out: dict) -> None:
+    keys = {k: out[k] for k in ("repo_key", "repos") if out.get(k)}
+    if not keys:
+        return
+    try:
+        try:
+            with open(_KEYS_FILE, encoding="utf-8") as f:
+                data = json.load(f)
+            data = data if isinstance(data, dict) else {}
+        except (OSError, ValueError):
+            data = {}
+        data[os.path.realpath(root)] = {**keys, "synced_at": time.time()}
+        if len(data) > 200:          # bounded: the newest roots
+            data = dict(sorted(data.items(), key=lambda kv: -float((kv[1] or {}).get("synced_at") or 0))[:200])
+        os.makedirs(os.path.dirname(_KEYS_FILE), exist_ok=True)
+        tmp = _KEYS_FILE + ".tmp"
+        with open(tmp, "w", encoding="utf-8") as f:
+            json.dump(data, f)
+        os.replace(tmp, _KEYS_FILE)
+    except OSError:
+        pass
+
+
 _MACHINE_ID_FILE = os.path.join(os.path.expanduser("~"), ".local", "share", "webbee", "machine-id")
 
 

{webbee-0.7.2 → webbee-0.7.3}/src/webbee/tools.py

@@ -551,8 +551,11 @@ class LocalToolExecutor:
                 parts.append("defines " + ", ".join(names[:2]) + extra)
             graph = getattr(self.indexer, "graph", None)
             if graph is not None and fi.symbols:
-                deps = sorted(graph.dependents_of({s.name for s in fi.symbols},
-                                                  depth=1) - {rel})
+                # the files whose references RESOLVE to this file (the vault's rules) -- never a file that only
+                # shares a name with one of its definitions (report 06.11 #2: "used by check-paths-agree.py, +50")
+                from webbee.intel.query import linker
+                deps = sorted({src for src, _u, _k, _l, dst, _q, _o in linker(self.indexer).links()
+                               if dst == rel and src != rel})
                 if deps:
                     extra = f" +{len(deps) - 3} more" if len(deps) > 3 else ""
                     parts.append("↔ used by " + ", ".join(deps[:3]) + extra)

{webbee-0.7.2 → webbee-0.7.3}/tests/test_intel_cache_and_sync_worker.py

@@ -306,7 +306,7 @@ def test_sync_now_waits_for_the_real_sync_and_answers_with_its_confirmation(tmp_
     kernel's request waits for its own sync to end and answers with what the vault took -- never "busy"."""
     import threading
     svc, slow = _service_with_slow_sync(tmp_path, monkeypatch)
-    svc.last_sync = {"repo_key": "k"}                      # not the first sync
+    svc._sync_taken = svc._sync_done = 1                  # not the first sync: a run already ended
     svc.sync_vault(None)
     assert slow.started.wait(5)
     got = {}

webbee-0.7.3/tests/test_intel_folder_1106.py

@@ -0,0 +1,109 @@
+"""Report 06.11 #2: a folder whose repositories sit one level deeper (core/<repo>, modules/<repo>) with loose
+scripts at its top was one 670-file project; the first sync answered "pending" for a whole session; the read
+header and graph_slice linked files by a shared name."""
+import os
+import subprocess
+import threading
+import time
+
+import pytest
+
+from webbee.intel import service as sv
+from webbee.intel.service import IntelService, find_repositories, is_repository, repo_of, sub_repositories
+
+
+def _repo(path):
+    os.makedirs(path, exist_ok=True)
+    os.makedirs(os.path.join(path, ".git"), exist_ok=True)
+
+
+@pytest.fixture(autouse=True)
+def _fresh(monkeypatch, tmp_path):
+    monkeypatch.setattr(sv, "_REPOS_SEEN", {})
+    monkeypatch.setattr(sv, "_KEYS_FILE", str(tmp_path / "keys" / "vault-keys.json"))
+
+
+def test_repositories_one_level_deeper_are_found_and_make_a_folder(tmp_path):
+    for r in ("core/wpanel-sdk", "modules/wpanel-tickets", "gateway"):
+        _repo(tmp_path / r)
+    _repo(tmp_path / "core/wpanel-sdk/vendor/inner")          # inside a repository: never its own unit
+    (tmp_path / "requirements.txt").write_text("x\n")         # a manifest and loose scripts at the top
+    (tmp_path / "check-paths-agree.py").write_text("print(1)\n")
+    assert find_repositories(str(tmp_path)) == ["gateway", "core/wpanel-sdk", "modules/wpanel-tickets"]
+    assert not is_repository(str(tmp_path))                    # a folder of repositories, not one project
+    assert sorted(sub_repositories(str(tmp_path))) == ["core/wpanel-sdk", "gateway", "modules/wpanel-tickets"]
+    assert repo_of("core/wpanel-sdk/src/a.py", sub_repositories(str(tmp_path))) == "core/wpanel-sdk"
+    assert repo_of("check-paths-agree.py", sub_repositories(str(tmp_path))) == ""
+
+
+def test_a_manifest_without_repositories_inside_is_a_project(tmp_path):
+    (tmp_path / "pyproject.toml").write_text("[project]\nname='x'\n")
+    assert is_repository(str(tmp_path))
+    _repo(tmp_path / "solo")
+    assert is_repository(str(tmp_path / "solo"))
+
+
+class _Slow:
+    def __init__(self, out=None):
+        self.started, self.release, self.calls, self.out = threading.Event(), threading.Event(), [], out
+
+    def __call__(self, rels=None, history=True):
+        self.calls.append((rels, history))
+        self.started.set()
+        self.release.wait(10)
+        return self.out if self.out is not None else {}
+
+
+def _svc(tmp_path, monkeypatch, out=None):
+    svc = IntelService(str(tmp_path), "rk", cache_dir=str(tmp_path / "c"))
+    svc.vault_client_factory = lambda: object()
+    slow = _Slow(out)
+    monkeypatch.setattr(svc, "_sync_vault", slow)
+    return svc, slow
+
+
+def test_the_first_sync_running_answers_with_the_keys_confirmed_last_time(tmp_path, monkeypatch):
+    sv.remember_keys(str(tmp_path), {"repo_key": "", "repos": {"gateway": "k1", "core/wpanel-sdk": "k2"}})
+    svc, slow = _svc(tmp_path, monkeypatch)
+    svc.sync_vault(None)
+    assert slow.started.wait(5)
+    got = svc.sync_now()
+    assert "pending" in got and got["known"]["repos"] == {"gateway": "k1", "core/wpanel-sdk": "k2"}
+    assert "cloud graph answers" in got["pending"]
+    slow.release.set()
+
+
+def test_pending_ends_with_the_first_run_even_when_it_failed(tmp_path, monkeypatch):
+    """Every tool call queued a sync; the kernel's ask always met one running and 'pending' never ended."""
+    svc, slow = _svc(tmp_path, monkeypatch, out={"repo_key": "", "partial_reason": "no repository here"})
+    slow.release.set()
+    svc.sync_vault(None)
+    deadline = time.time() + 5
+    while svc._sync_done == 0:
+        assert time.time() < deadline
+        time.sleep(0.01)
+    slow.release.clear()
+    svc.sync_vault(None)                                       # the next tool call's sync is running
+    assert slow.started.wait(5)
+    got = {}
+    th = threading.Thread(target=lambda: got.update(svc.sync_now()))
+    th.start()
+    time.sleep(0.2)
+    assert th.is_alive() and not got                           # waits for a real outcome, never "pending" again
+    slow.release.set()
+    th.join(10)
+    assert got.get("ok") is False and "no repository here" in got["content"]
+
+
+def test_graph_slice_callers_are_resolved_users(tmp_path):
+    pytest.importorskip("tree_sitter_python")
+    (tmp_path / "lib.py").write_text("def session_for_sid(sid):\n    return sid\n")
+    (tmp_path / "api.py").write_text("from lib import session_for_sid\n\n\ndef me(sid):\n"
+                                     "    return session_for_sid(sid)\n")
+    (tmp_path / "other.py").write_text("def unrelated():\n    return 'session_for_sid'\n")
+    subprocess.run(["git", "init", "-q", str(tmp_path)], check=False)
+    svc = IntelService(str(tmp_path), "rk", cache_dir=str(tmp_path / "c"))
+    svc.build()
+    from webbee.intel.query import graph_slice
+    item = graph_slice(svc, ["session_for_sid"])["data"]["items"][0]
+    assert [(c["path"], c["user"], c["line"]) for c in item["callers"]] == [("api.py", "me", 5)]

{webbee-0.7.2 → webbee-0.7.3}/tests/test_tools.py

@@ -538,13 +538,20 @@ def test_read_header_enriched_with_graph_context(tmp_path):
             Symbol("helper", "function", "a.py", 4, 5)]),
         "b.py": FileIndex(path="b.py", lang="python", refs=["Alpha"]),
     })
-    class _Svc:  # duck-typed IntelService: .index + .graph is all the header reads
+    class _Svc:  # duck-typed IntelService: .root + .index + .graph is all the header reads
+        root = str(tmp_path)
         index = idx
         graph = CodeGraph(idx)
     ex = LocalToolExecutor(str(tmp_path), indexer=_Svc())
     header = ex.run("read_file", {"path": "a.py"})["content"].split("\n", 1)[0]
     assert "defines Alpha, helper" in header
     assert "↔ used by b.py" in header
+    # 06.11 #2: a file that only shares a name is no user (it was "used by check-paths-agree.py, +50 more")
+    (tmp_path / "c.py").write_text("print('Alpha')\nAlpha = 1\n")
+    idx.files["c.py"] = FileIndex(path="c.py", lang="python", refs=["Alpha"])
+    _Svc.graph = CodeGraph(idx)
+    header = ex.run("read_file", {"path": "a.py"})["content"].split("\n", 1)[0]
+    assert "↔ used by b.py" in header and "c.py" not in header
     assert "5 lines" in header                    # cheap metadata still present
 
 

webbee-0.7.2/src/webbee/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.7.2"