webbee 0.7.0__tar.gz → 0.7.2__tar.gz

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

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.7.2
+
+* **The code graph answers correctly** (06.11 report):
+  * `impact_of_change` lists the files that really use a symbol, with the line, the user and the depth. A
+    function nobody calls had answered 481 unrelated files.
+  * Files that only share the name are listed apart under `by_name`.
+  * An unknown symbol is reported as such, never as "0 users".
+* **Every major language is linked**:
+  * Go, Rust, Java, Kotlin, C#, PHP, Ruby;
+  * TS/JS monorepos (workspace packages, tsconfig `extends`, default exports, CommonJS, `.mts/.cts`);
+  * Vue, Svelte and Astro components;
+  * members through typed fields, constructors and return types.
+* **Projects of every ecosystem** are recognised (`Cargo.toml`, `go.mod`, `pom.xml`, `*.csproj`, `composer.json`,
+  `Gemfile` ...), locally and on servers.
+* `.gitignore` rules apply in folders without git and on machines without a git binary (Windows).
+* Needs imperal-mcp 0.9.2 and imperal-sdk 6.5.0.
+
+## 0.7.1
+
+* **A missing code index says why**: when the index did not start (a failure while building it, or it is turned off),
+  `impact_of_change`, `graph_slice` and the other code-map tools now name the real reason instead of the wrong
+  "install webbee[intel]" -- the index has shipped in the base install since 0.7.0, there is nothing to install.
+* Needs imperal-mcp 0.9.1 (install commands that work on Debian 12+, Ubuntu 23.04+ and Homebrew: `pipx` / `uv tool`).
+
 ## 0.7.0
 
 * **The local index takes any folder and every file kind**: open webbee in a home folder, a folder of contracts or a

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: webbee
-Version: 0.7.0
+Version: 0.7.2
 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.0; python_version >= '3.10'
-Requires-Dist: imperal-sdk[universal-index]>=6.4.1; 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: 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.0 → webbee-0.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "webbee"
-version = "0.7.0"
+version = "0.7.2"
 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.0; python_version >= "3.10"',   # raised to the newest at each release
-    'imperal-sdk[universal-index]>=6.4.1; 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"',
     '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.2/src/webbee/__init__.py

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

{webbee-0.7.0 → webbee-0.7.2}/src/webbee/boot.py

@@ -7,6 +7,11 @@ import asyncio
 import os
 import subprocess
 
+# Why the code index is NOT running in this process ("" while it runs or before the boot). The boot swallows the
+# failure so the REPL never crashes -- but a tool that needs the index must be able to say the real reason instead of
+# guessing ("install webbee[intel]" was wrong since 0.7.0: intel ships in the base install).
+INTEL_DOWN_REASON = ""
+
 
 def _git_branch(workspace: str) -> str:
     try:
@@ -105,6 +110,7 @@ async def start_intel(cfg, workspace: str, intel_factory):
     failure here (missing extra, bad repo, etc.) must degrade to
     (None, None), never crash the boot -- coding still works, just
     without repo intelligence. Returns (intel, watcher_task)."""
+    global INTEL_DOWN_REASON
     try:
         svc = (intel_factory or _default_intel_factory)(cfg, workspace)
         await asyncio.to_thread(svc.build)
@@ -118,8 +124,10 @@ async def start_intel(cfg, workspace: str, intel_factory):
         # its end is always collected: an exception is never printed when webbee quits ("Task exception was never
         # retrieved", live 2026-10-25)
         watcher_task.add_done_callback(lambda t: t.cancelled() or t.exception())
+        INTEL_DOWN_REASON = ""
         return svc, watcher_task
-    except Exception:
+    except Exception as exc:
+        INTEL_DOWN_REASON = f"the code index failed to start: {type(exc).__name__}: {str(exc)[:200]}"
         return None, None
 
 
@@ -155,10 +163,12 @@ async def boot_workspace(cfg, workspace: str, intel_factory, shadow_factory) ->
     behavior per job (a crash in one never blocks the others or the boot),
     just concurrent instead of serial."""
     async def _intel_job():
+        global INTEL_DOWN_REASON
         if cfg.intel_enabled:
             # Guarded off-loop build + watcher; any failure degrades to
             # intel=None, never crashes the boot (start_intel above).
             return await start_intel(cfg, workspace, intel_factory)
+        INTEL_DOWN_REASON = "the code index is turned off in this configuration (intel_enabled = false)"
         return None, None
 
     (intel, watcher_task), shadow, git_branch = await asyncio.gather(

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

@@ -186,14 +186,101 @@ def contract_slice(svc, query: str = "", kind: str = "all", k: int = 50) -> dict
     return _env(items[:limit], has_more=len(items) > limit)
 
 
+# The local answer of ``impact_of_change`` computes links the way the vault's graph does (imperal_sdk.code_links,
+# 2026-11-06): before, a file "depended" on a symbol when the bare NAME appeared in it, and each depth step pulled in
+# every definition of every hit file -- a function nobody calls answered 481 files (06.11 report).
+# which files carry scope facts and which are resolution configs: the SDK's one answer (Python, TS/JS, Vue/Svelte/Astro,
+# Go, Rust, Java, Kotlin, C#, PHP, Ruby; go.mod, Cargo.toml, tsconfig, package.json ...) -- never a list of our own
+_FACTS: dict = {}            # (root, path, content_hash) -> BlobFacts | None: a file parsed once per content
+_FACTS_MAX = 60000
+_READ_MAX = 2_000_000
+
+
+def _read(root: str, rel: str):
+    import os
+    try:
+        full = os.path.join(root, rel)
+        if os.path.getsize(full) > _READ_MAX:
+            return None
+        with open(full, encoding="utf-8", errors="replace") as fh:
+            return fh.read()
+    except OSError:
+        return None
+
+
+def _is_config(rel: str) -> bool:
+    from imperal_sdk.code_index import is_resolution_config
+    return is_resolution_config(rel)
+
+
+def linker(svc):
+    """The repo's resolver (``imperal_sdk.code_links.Linker``) for the index's current graph -- built once per graph
+    (a rebuilt graph builds it again), each file parsed once per content."""
+    import os
+    g = svc.graph
+    if getattr(svc, "_linker_graph", None) is g and getattr(svc, "_linker", None) is not None:
+        return svc._linker
+    from imperal_sdk import code_index as ci
+    from imperal_sdk.code_links import Linker
+    root = str(getattr(svc, "root", "") or "")
+    if len(_FACTS) > _FACTS_MAX:
+        _FACTS.clear()
+    facts: dict = {}
+    for path, fi in list(svc.index.files.items()):
+        if not ci.has_scope_facts(path):
+            continue
+        key = (root, path, getattr(fi, "content_hash", ""))
+        if key not in _FACTS:
+            text = _read(root, path) if root else None
+            _FACTS[key] = ci.scope_facts(path, text) if text is not None else None
+        facts[path] = _FACTS[key]
+    configs = []
+    cands = {p for p in svc.index.files if _is_config(p)}
+    if root:
+        cands |= {n for n in os.listdir(root) if _is_config(n)} if os.path.isdir(root) else set()
+    for rel in sorted(cands):
+        text = _read(root, rel) if root else None
+        if text is None:
+            continue
+        try:
+            kind, data = ci.parse_config(rel, text)
+        except Exception:
+            continue
+        configs.append({"path": rel.replace("\\", "/"), "kind": kind, "data": data})
+    lk = Linker(facts, configs)
+    svc._linker, svc._linker_graph = lk, g
+    return lk
+
+
 def impact_of_change(svc, symbols) -> dict:
+    """Files that use ``symbols`` (resolved links: line, user, depth through the enclosing definition), code before
+    tests; ``by_name`` -- files that only share a name (a method on a local, a language without scope facts), marked
+    and bounded; ``resolved`` -- the definitions found (none: "not a definition in this index", never "0 users")."""
     if svc is None or svc.graph is None:
         return {"ok": False, "content": "index not ready"}
     if isinstance(symbols, str):
         symbols = [symbols]
-    files = svc.graph.dependents_of(list(symbols or []), depth=3)
-    items = [{"id": f, "title": f, "kind": "file"} for f in sorted(files)]
-    return _env(items)
+    from imperal_sdk.code_index import has_scope_facts
+    from imperal_sdk.code_links import BY_NAME_SHOWN, impact, is_test_path
+    syms = [str(s) for s in (symbols or []) if str(s).strip()]
+    out = impact(linker(svc), syms, depth=2)
+    # languages without scope facts: their uses are known by name only -- listed with the other by-name files
+    names = {s.split("::")[-1].split(":")[-1].rsplit(".", 1)[-1] for s in syms}
+    known = {b["path"] for b in out["by_name"]} | {i["id"] for i in out["data"]["items"]}
+    extra = []
+    for path, fi in svc.index.files.items():
+        if has_scope_facts(path) or path in known:
+            continue
+        if names & set(getattr(fi, "refs", ()) or ()):
+            extra.append({"path": path, "line": 0, "name": "", "group": "tests" if is_test_path(path) else "code",
+                          "note": "no scope facts for this language: by name"})
+    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]
+    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"
+    return out
 
 
 def orient(svc, q) -> dict:

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

@@ -171,10 +171,22 @@ def _index_listing(root: str, focus: str | None = None, limit: int = UNIT_MAX_FI
     skipped = {"placeholder": 0, "over_cap": 0}
     excluded = {str(e).strip("/") for e in exclude if str(e).strip("/")}
     listed = _git_listed(root)
+    # no git answer (a folder that is no repository, the repositories inside it, a machine without git -- Windows,
+    # a minimal Linux): every .gitignore on the way applies, read here (06.11 report: none applied, ~19.6k dump and
+    # screenshot files were indexed). The same parser as the SFTP listing (imperal_sdk.code_index.gitignore_rules).
+    from imperal_sdk.code_index import gitignore_rules, gitignored
+    rules: list | None = None if listed is not None else []
     for dp, dns, fns in os.walk(root):
         here = os.path.relpath(dp, root).replace(os.sep, "/")
+        if rules is not None and ".gitignore" in fns:
+            try:
+                with open(os.path.join(dp, ".gitignore"), encoding="utf-8", errors="replace") as fh:
+                    rules = rules + gitignore_rules(fh.read(), "" if here == "." else here)
+            except OSError:
+                pass
         dns[:] = sorted(d for d in dns if not skipped_dir(dp, d)
-                        and (d if here == "." else f"{here}/{d}") not in excluded)
+                        and (d if here == "." else f"{here}/{d}") not in excluded
+                        and not (rules and gitignored(rules, d if here == "." else f"{here}/{d}", True)))
         for fn in sorted(fns):
             rel = fn if here == "." else f"{here}/{fn}"
             if is_placeholder(rel):
@@ -182,6 +194,8 @@ def _index_listing(root: str, focus: str | None = None, limit: int = UNIT_MAX_FI
                 continue
             if listed is not None and rel not in listed:
                 continue
+            if rules and gitignored(rules, rel, False):
+                continue
             if kind_of(rel, root=root) is None:
                 continue
             try:
@@ -990,9 +1004,8 @@ class IntelService:
 
 # ── code graph everywhere (plan 3 Tasks 7, 9): the local workspace in the vault's one graph ─────────
 
-# what makes a folder a project for the code graph: version control or a manifest of an indexable language at its root
-# (the sdk's config names; Python and JS/TS are what the index reads)
-_MANIFESTS = tuple(indexer.CONFIG_NAMES) + ("setup.py", "requirements.txt", "tsconfig.json")
+# what makes a folder a project for the code graph: version control or any ecosystem's manifest at its root -- the
+# sdk's one rule (``indexer.is_project_root``: Cargo.toml, go.mod, pom.xml, *.csproj, composer.json, Gemfile, ...)
 
 
 SUB_REPOS_MAX = 40     # a folder of projects: at most this many of its repositories are synced
@@ -1025,7 +1038,7 @@ def is_repository(root: str) -> bool:
         names = set(os.listdir(root))
     except OSError:
         return False
-    return ".git" in names or any(m in names for m in _MANIFESTS)
+    return indexer.is_project_root(names)
 
 
 _MACHINE_ID_FILE = os.path.join(os.path.expanduser("~"), ".local", "share", "webbee", "machine-id")

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

@@ -1002,7 +1002,11 @@ class LocalToolExecutor:
 
     def _cpc_local(self, verb: str, a: dict) -> dict:
         if self.indexer is None:
-            return {"ok": False, "content": "intel not available; install webbee[intel]"}
+            from webbee import boot
+            why = boot.INTEL_DOWN_REASON or "the code index is not running in this session"
+            return {"ok": False, "content": f"intel not available: {why}. It ships with webbee (no extra to install); "
+                                            "restart webbee in the repository, and if it repeats, see "
+                                            "~/.cache/webbee/tui-stderr.log"}
         from webbee.intel import query
         if verb == "repo_profile":
             return query.repo_profile(self.indexer)
@@ -1366,7 +1370,7 @@ async def _no_repo_at(sftp, ci, root: str) -> str:
         names = {e.filename for e in await sftp.readdir(repo_root)}
     except Exception:
         names = set()
-    if not names & (set(getattr(ci, "_REPO_MARKERS", (".git",))) | set(getattr(ci, "_MANIFESTS", ()))):
+    if not ci.is_project_root(names):
         return f"{root} is in no repository (no .git or project manifest at it or above)"
     return ""
 

{webbee-0.7.0 → webbee-0.7.2}/tests/test_intel_any_folder.py

@@ -95,3 +95,24 @@ def test_a_secret_written_later_is_never_read_and_the_profile_names_no_document(
     assert "credentials.json" not in svc.index.files and not any("credentials.json" in o for o in opened)
     prof = svc.repo_profile()
     assert not any("Agreement" in s for s in prof["top_symbols"]) and prof["other_kinds"]["document"] >= 2
+
+
+
+def test_gitignore_applies_without_git(tmp_path, monkeypatch):
+    """06.11 report: in a folder without git (or on a machine without the git binary) no .gitignore applied."""
+    from webbee.intel import service
+    (tmp_path / ".gitignore").write_text("dumps/\n*.png\n")
+    (tmp_path / "dumps").mkdir()
+    (tmp_path / "dumps" / "big.sql").write_text("x")
+    (tmp_path / "shot.png").write_bytes(b"\x89PNG")
+    (tmp_path / "app.py").write_text("x = 1\n")
+    (tmp_path / "sub").mkdir()
+    (tmp_path / "sub" / ".gitignore").write_text("local.py\n")
+    (tmp_path / "sub" / "local.py").write_text("y = 1\n")
+    (tmp_path / "sub" / "keep.py").write_text("z = 1\n")
+    rels, _stats, _skipped = service._index_listing(str(tmp_path))
+    assert "app.py" in rels and "sub/keep.py" in rels
+    assert not {"dumps/big.sql", "shot.png", "sub/local.py"} & set(rels)
+    # the same with git present but failing (no binary): the rules still apply
+    monkeypatch.setattr(service, "_git_listed", lambda root: None)
+    assert "sub/local.py" not in service._index_listing(str(tmp_path))[0]

{webbee-0.7.0 → webbee-0.7.2}/tests/test_intel_query.py

@@ -5,7 +5,7 @@ from webbee.intel import query
 
 
 def _svc(tmp_path):
-    (tmp_path / "a.py").write_text("def alpha():\n    return beta()\n")
+    (tmp_path / "a.py").write_text("from b import beta\n\n\ndef alpha():\n    return beta()\n")
     (tmp_path / "b.py").write_text("def beta():\n    return 1\n")
     s = IntelService(str(tmp_path), "rk", cache_dir=str(tmp_path / "c")); s.build(); return s
 
@@ -83,3 +83,32 @@ def test_search_code_kind_filter_does_not_nullify_vector_arm(tmp_path, monkeypat
     monkeypatch.setattr(query, "_lexical_search", lambda *a, **k: [])
     r = query.search_code(svc, "beta", kind="function")
     assert r["ok"] and any(i["title"] == "beta" for i in r["data"]["items"])
+
+
+# 06.11 report: a function nobody calls answered hundreds of files (links by bare name, depth through every def of a
+# hit file). The local answer now follows the vault's rules (imperal_sdk.code_links).
+
+def _svc2(tmp_path):
+    (tmp_path / "core.py").write_text("def used():\n    return 1\n\n\ndef lonely():\n    return 2\n")
+    (tmp_path / "user.py").write_text("from core import used\n\n\ndef run():\n    return used()\n")
+    (tmp_path / "other.py").write_text("def go(obj):\n    return obj.lonely()\n\n\ndef used_twice():\n    return 3\n")
+    (tmp_path / "tests").mkdir()
+    (tmp_path / "tests" / "test_core.py").write_text("from core import used\n\n\ndef test_used():\n    assert used()\n")
+    s = IntelService(str(tmp_path), "rk2", cache_dir=str(tmp_path / "c")); s.build(); return s
+
+
+def test_impact_nobody_calls_is_empty_and_by_name_is_apart(tmp_path):
+    r = query.impact_of_change(_svc2(tmp_path), ["lonely"])
+    assert r["data"]["items"] == [] and r["resolved"] == ["core.py::lonely"]
+    assert [b["path"] for b in r["by_name"]] == ["other.py"]
+
+
+def test_impact_resolved_users_code_before_tests(tmp_path):
+    r = query.impact_of_change(_svc2(tmp_path), ["used"])
+    assert [i["id"] for i in r["data"]["items"]] == ["user.py", "tests/test_core.py"]
+    assert r["data"]["items"][0]["user"] == "run" and r["data"]["items"][0]["line"] == 5
+
+
+def test_impact_unknown_symbol_says_so(tmp_path):
+    r = query.impact_of_change(_svc2(tmp_path), ["nope"])
+    assert r["data"]["items"] == [] and "not a definition" in r["note"]

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

@@ -178,6 +178,21 @@ def test_cpc_shim_degrades_without_indexer(tmp_path):
     ex = LocalToolExecutor(str(tmp_path))            # indexer=None
     out = ex.run("graph_slice", {"symbols": ["x"]})
     assert out["ok"] is False and "intel not available" in out["content"]
+    assert "install webbee[intel]" not in out["content"]   # intel ships in the base install since 0.7.0
+
+
+def test_cpc_shim_says_why_the_index_is_down(tmp_path, monkeypatch):
+    import asyncio
+    from webbee import boot
+    from webbee.tools import LocalToolExecutor
+
+    def broken_factory(cfg, ws):
+        raise PermissionError("cannot write the index cache")
+    monkeypatch.setattr(boot, "INTEL_DOWN_REASON", "")
+    assert asyncio.run(boot.start_intel(object(), str(tmp_path), broken_factory)) == (None, None)
+    out = LocalToolExecutor(str(tmp_path)).run("impact_of_change", {"symbols": ["x"]})
+    assert out["ok"] is False
+    assert "PermissionError: cannot write the index cache" in out["content"]
 
 
 def test_cpc_graph_slice_coerces_stringified_symbols(tmp_path):
@@ -187,7 +202,7 @@ def test_cpc_graph_slice_coerces_stringified_symbols(tmp_path):
     # false negative the brain reads as "no callers".
     pytest.importorskip("tree_sitter")
     from webbee.intel.service import IntelService
-    (tmp_path / "a.py").write_text("def alpha():\n    return beta()\n")
+    (tmp_path / "a.py").write_text("from b import beta\n\n\ndef alpha():\n    return beta()\n")   # a real import: links are resolved
     (tmp_path / "b.py").write_text("def beta():\n    return 1\n")
     svc = IntelService(str(tmp_path), "rk", cache_dir=str(tmp_path / "c"))
     svc.build()

webbee-0.7.0/src/webbee/__init__.py

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