webbee 0.7.1__tar.gz → 0.7.3__tar.gz

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

@@ -1,5 +1,41 @@
 # 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):
+  * `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),

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "webbee"
-version = "0.7.1"
+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.1; 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.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.1 → 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)
 
 
@@ -186,14 +206,111 @@ 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})
+    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
+
+
 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]
+    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"
+    return out
 
 
 def orient(svc, q) -> dict:

{webbee-0.7.1 → 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
@@ -171,10 +172,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 +195,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:
@@ -740,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}
@@ -752,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()
@@ -801,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:
@@ -830,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)
@@ -990,42 +1016,116 @@ 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
+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
-    return ".git" in names or any(m in names for m in _MANIFESTS)
+    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.1 → 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)
@@ -1370,7 +1373,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.1 → webbee-0.7.3}/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.1 → 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)]