imperal-sdk 6.5.0__tar.gz → 6.5.2__tar.gz

{imperal_sdk-6.5.0 → imperal_sdk-6.5.2}/.github/workflows/test.yml

@@ -40,6 +40,12 @@ jobs:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
         python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
+        exclude:
+          - os: ubuntu-latest          # its image carries no 3.9 (end of life): the same Linux on 22.04 below
+            python-version: "3.9"
+        include:
+          - os: ubuntu-22.04
+            python-version: "3.9"
 
     steps:
       - uses: actions/checkout@v4

{imperal_sdk-6.5.0 → imperal_sdk-6.5.2}/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 All notable changes to `imperal-sdk` are documented here.
 
+## 6.5.2 - 2026-11-06
+
+### Fixed
+- `impact()` depth grows only through the definition that uses the symbol. A module-level use no longer counts as
+  "the whole file", so depth 2 no longer lists every file that imports anything from that module (found on a live
+  check).
+
+## 6.5.1 - 2026-11-06
+
+Fixes from the second 06.11 field report (Webbee 0.7.2 in a folder of nine repositories).
+
+### Fixed
+- `code_links`: a folder of repositories indexed as one resolves each absolute import in its OWN repository first.
+  `Linker(facts, configs, roots)` takes the repository roots; config directories are project roots too. Before,
+  `from app.sessions import ...` inside `gateway/` resolved nowhere, and two repositories with the same module names
+  took each other's files.
+- `impact()` carries a `summary`: one sentence that can't be misread. "0 resolved users, 11 files only mention the
+  name" is no longer read as "no callers".
+- Python members are resolved through typed values:
+  - typed locals and parameters (`Optional[...]`, forward references);
+  - `self.x` attributes and dataclass fields;
+  - return annotations.
+
+  A member of an unannotated call result is never linked to the call.
+
 ## 6.5.0 - 2026-11-06
 
 The code graph, fixed after the 06.11 report: one link algorithm for the vault and every client, every major

{imperal_sdk-6.5.0 → imperal_sdk-6.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: imperal-sdk
-Version: 6.5.0
+Version: 6.5.2
 Summary: SDK for building Imperal Cloud extensions
 Author: Imperal, Inc.
 Author-email: Valentin Scerbacov <valentin@imperal.io>

{imperal_sdk-6.5.0 → imperal_sdk-6.5.2}/sdk-reference.json

@@ -1,5 +1,5 @@
 {
-  "sdk_version": "6.5.0",
+  "sdk_version": "6.5.2",
   "symbols": {
     "ActionResult": {
       "action_vocab_safe": false,

{imperal_sdk-6.5.0 → imperal_sdk-6.5.2}/sdk_claims.json

@@ -1,5 +1,5 @@
 {
-  "_sdk_version": "6.5.0",
+  "_sdk_version": "6.5.2",
   "constants": {
     "max_call_depth": {
       "counts_root": true,

{imperal_sdk-6.5.0 → imperal_sdk-6.5.2}/src/imperal_sdk/__init__.py

@@ -1,7 +1,7 @@
 """Imperal Cloud SDK — build extensions for the Imperal platform."""
 from typing import TYPE_CHECKING
 
-__version__ = "6.5.0"
+__version__ = "6.5.2"
 
 # 5.2.2 (2026-06-11): the package root resolves its public surface lazily
 # (PEP 562). The eager imports pulled the HTTP transport (Context / client

{imperal_sdk-6.5.0 → imperal_sdk-6.5.2}/src/imperal_sdk/code_index.py

@@ -1168,6 +1168,113 @@ def _py_walk(sc: _Scope, node, scope: list, ctx: str, local: set, exported_names
         _py_walk(sc, c, scope, ctx, local, exported_names, is_init)
 
 
+def _py_type(sc: _Scope, node) -> list | None:
+    """A Python annotation as a chain: ``Repo``, ``db.Conn``, ``Optional[Repo]`` / ``Repo | None`` -> the class;
+    a builtin generic (``list[X]``, ``dict``) or anything else -> None."""
+    if node is None:
+        return None
+    if node.type == "type" and node.named_children:
+        node = node.named_children[0]
+    if node.type in ("identifier", "attribute"):
+        parts = sc.text(node).replace(" ", "").split(".")
+        return parts if all(_IDENT_SHAPE.match(x) for x in parts) and parts[-1] not in _PY_BUILTINS else None
+    if node.type == "binary_operator":                       # X | None
+        for side in ("left", "right"):
+            got = _py_type(sc, node.child_by_field_name(side))
+            if got and got != ["None"]:
+                return got
+        return None
+    if node.type in ("subscript", "generic_type"):          # Optional[X], Annotated[X, ...]
+        head = node.child_by_field_name("value") or (node.named_children[0] if node.named_children else None)
+        if head is not None and sc.text(head).rsplit(".", 1)[-1] in ("Optional", "Annotated"):
+            inner = [c for c in node.named_children if c is not None and c.start_byte != head.start_byte]
+            if inner and inner[0].type == "type_parameter":
+                inner = list(inner[0].named_children)
+            return _py_type(sc, inner[0]) if inner else None
+        return None
+    if node.type == "string":                                # a forward reference: 'Repo'
+        body = "".join(sc.text(c) for c in node.named_children if c.type == "string_content").strip()
+        parts = body.split(".")
+        return parts if body and all(_IDENT_SHAPE.match(x) for x in parts) else None
+    return None
+
+
+def _py_value_type(sc: _Scope, value) -> list | None:
+    """``Repo(...)`` / ``db.Conn(...)`` -> the class (a capitalized callee); ``make_repo(...)`` -> ``[make_repo, "()"]``
+    (the value its declared return type names -- resolved through its ``returns`` binding)."""
+    if value is None:
+        return None
+    if value.type == "await" and value.named_children:
+        value = value.named_children[0]
+    if value.type != "call":
+        return None
+    fn = value.child_by_field_name("function")
+    chain = _py_chain(sc, fn) if fn is not None else None
+    if not chain or chain[0] in _PY_BUILTINS:
+        return None
+    return chain if chain[-1][:1].isupper() else chain + ["()"]
+
+
+def _py_typed(sc: _Scope, fn) -> dict:
+    """``{local: type chain}`` of a Python function: annotated parameters, ``x: T = ...``, ``x = T(...)``,
+    ``x = make()`` (through make's return annotation)."""
+    out: dict = {}
+    params = fn.child_by_field_name("parameters")
+    for p in (params.named_children if params is not None else []):
+        if p.type in ("typed_parameter", "typed_default_parameter"):
+            n = p.child_by_field_name("name") or next((c for c in p.named_children if c.type == "identifier"), None)
+            ch = _py_type(sc, p.child_by_field_name("type"))
+            if n is not None and ch:
+                out[sc.text(n)] = ch
+    stack = list((fn.child_by_field_name("body") or fn).children)
+    while stack:
+        n = stack.pop()
+        if n.type in ("function_definition", "class_definition", "lambda"):
+            continue
+        if n.type == "assignment":
+            left = n.child_by_field_name("left")
+            if left is not None and left.type == "identifier":
+                ch = _py_type(sc, n.child_by_field_name("type")) or _py_value_type(sc, n.child_by_field_name("right"))
+                if ch:
+                    out[sc.text(left)] = ch
+        stack.extend(n.children)
+    return out
+
+
+def _py_fields(sc: _Scope, cls) -> dict:
+    """``{attribute: type chain}`` of a Python class: annotated class attributes (dataclasses, pydantic) and
+    ``self.x = T(...)`` / ``self.x: T`` / ``self.x = param`` (a typed parameter) in its methods."""
+    out: dict = {}
+    body = cls.child_by_field_name("body")
+    for st in (body.named_children if body is not None else []):
+        expr = st.named_children[0] if st.type == "expression_statement" and st.named_children else st
+        if expr.type == "assignment":
+            left = expr.child_by_field_name("left")
+            ch = _py_type(sc, expr.child_by_field_name("type")) or _py_value_type(sc, expr.child_by_field_name("right"))
+            if left is not None and left.type == "identifier" and ch:
+                out[sc.text(left)] = ch
+        fn = st.child_by_field_name("definition") if st.type == "decorated_definition" else st
+        if fn is None or fn.type != "function_definition":
+            continue
+        params = _py_typed(sc, fn)
+        stack = list((fn.child_by_field_name("body") or fn).children)
+        while stack:
+            n = stack.pop()
+            if n.type in ("function_definition", "class_definition", "lambda"):
+                continue
+            if n.type == "assignment":
+                left = n.child_by_field_name("left")
+                if left is not None and left.type == "attribute" and sc.text(left).startswith("self."):
+                    attr = sc.text(left)[5:]
+                    right = n.child_by_field_name("right")
+                    ch = (_py_type(sc, n.child_by_field_name("type")) or _py_value_type(sc, right)
+                          or (params.get(sc.text(right)) if right is not None and right.type == "identifier" else None))
+                    if ch and "." not in attr:
+                        out.setdefault(attr, ch)
+            stack.extend(n.children)
+    return out
+
+
 def _py_def(sc: _Scope, node, outer, scope: list, local: set, exported_names, is_init: bool) -> None:
     name_node = node.child_by_field_name("name")
     if name_node is None:
@@ -1183,6 +1290,17 @@ def _py_def(sc: _Scope, node, outer, scope: list, local: set, exported_names, is
         exp = bool(parent[2]) and parent[1] == "class" and not name.startswith("_")
     sc.defs.append(Def(name, qual, kind, _line_of(outer), node.end_point[0] + 1,
                        _first_line(sc.text(node)), exp))
+    if is_class:
+        fields = _py_fields(sc, node)
+        if fields:
+            sc.fields[qual] = fields
+    else:
+        typed = _py_typed(sc, node)
+        if typed:
+            sc.typed[qual] = typed
+        rch = _py_type(sc, node.child_by_field_name("return_type"))
+        if rch:
+            sc.bindings.append(Binding(qual + "()", "", ".".join(rch), "returns", _line_of(outer)))
     inner = (qual, "class" if is_class else "function", exp)
     sup = node.child_by_field_name("superclasses")
     if sup is not None:

{imperal_sdk-6.5.0 → imperal_sdk-6.5.2}/src/imperal_sdk/code_links.py

@@ -64,19 +64,31 @@ def is_test_path(path: str) -> bool:
 
 # ---- module resolution (the vault's stitching code, §4.6.3) ----
 
-def module_index(paths, configs: list) -> dict:
+def module_index(paths, configs: list, roots=()) -> dict:
     """The repo's files as the resolver probes them: every path (exact and case-blind), and every
     Python module name under each package root -- the repo root, ``src/`` layouts, the roots the
     configs declare (pyproject ``where`` / ``package-dir``, setup.cfg ``package_dir``) and the top
-    of each ``__init__.py`` chain."""
+    of each ``__init__.py`` chain.
+
+    ``roots``: the repositories inside a folder indexed as one (``core/wpanel-sdk``, ``gateway``). With the
+    directories of the project configs they are PROJECT roots: an absolute import is looked up first among the
+    names of the project holding the importing file (report 06.11 #2: ``from app.sessions import ...`` inside
+    ``gateway/`` resolved nowhere, and two repos with the same module names took each other's files)."""
     paths = sorted(set(paths), key=lambda p: (not p.endswith(".py"), p))
     files = set(paths)
     lower: dict = {}
     for p in paths:
         lower.setdefault(p.lower(), p)
-    roots = {""}
+    projects = {""} | {_slashes(str(r)).strip("/") for r in roots or () if str(r).strip("/.")}
+    for c in configs or []:
+        if c.get("kind") in ("pyproject", "setup_cfg", "package_json", "go_mod", "cargo"):
+            projects.add(posixpath.dirname(_slashes(str(c.get("path") or "")).lstrip("/")))
+    roots = set(projects)
     if any(p.startswith("src/") for p in paths):
         roots.add("src")
+    for pr in projects:
+        if pr and any(p.startswith(pr + "/src/") for p in paths):
+            roots.add(pr + "/src")
     for c in configs or []:
         data = c.get("data") or {}
         base = posixpath.dirname(str(c.get("path") or ""))
@@ -86,6 +98,7 @@ def module_index(paths, configs: list) -> dict:
             if str(k) == "" and v:
                 roots.add(_slashes(posixpath.join(base, str(v))).lstrip("/"))
     py: dict = {}
+    by_root: dict = {}
     inits = {posixpath.dirname(p) for p in paths if posixpath.basename(p) in ("__init__.py", "__init__.pyi")}
     for p in paths:
         if not p.endswith(_PY_EXT):
@@ -99,12 +112,13 @@ def module_index(paths, configs: list) -> dict:
         while top and top in inits:
             top = posixpath.dirname(top)
         mine.add(top)
-        for root in mine:
+        for root in sorted(mine):
             if root and not (stem == root or stem.startswith(root + "/")):
                 continue
             rel = stem[len(root) + 1:] if root else stem
             if rel:
                 py.setdefault(rel.replace("/", "."), p)
+                by_root.setdefault(root, {}).setdefault(rel.replace("/", "."), p)
     pkgs = {}
     for c in configs or []:
         if c.get("kind") == "package_json" and (c.get("data") or {}).get("name"):
@@ -112,7 +126,21 @@ def module_index(paths, configs: list) -> dict:
     by_path = {_slashes(str(c.get("path") or "")).lstrip("/"): c for c in configs or []}
     ts = [dict(c, eff=_ts_effective(c, by_path, pkgs, set()))
           for c in configs or [] if c.get("kind") in ("tsconfig", "jsconfig")]
-    return {"files": files, "lower": lower, "py": py, "ts": ts, "pkgs": pkgs}
+    return {"files": files, "lower": lower, "py": py, "ts": ts, "pkgs": pkgs, "py_roots": by_root,
+            "projects": sorted(projects, key=len, reverse=True)}
+
+
+def _py_absolute(modules: dict, from_path: str, spec: str) -> str | None:
+    """An absolute Python module: first among the names of the project holding ``from_path`` (its own roots),
+    then anywhere (a package another project of the folder provides: ``wpanel_sdk`` from ``core/wpanel-sdk``)."""
+    proj = next((r for r in modules.get("projects") or () if not r or from_path.startswith(r + "/")), "")
+    if proj:
+        for root in sorted(modules.get("py_roots") or {}):
+            if root == proj or root.startswith(proj + "/"):
+                got = modules["py_roots"][root].get(spec)
+                if got:
+                    return got
+    return modules["py"].get(spec)
 
 
 def _ts_effective(c: dict, by_path: dict, pkgs: dict, seen: set) -> dict:
@@ -234,7 +262,7 @@ def resolve_module(modules: dict, from_path: str, spec: str, lang: str, configs:
                 parts = parts[:len(parts) - (level - 1)]
             target = "/".join(parts + ([x for x in rest.split(".") if x] if rest else []))
             return _probe(modules, target, "python") if target else _probe(modules, "__init__", "python")
-        return modules["py"].get(spec)
+        return _py_absolute(modules, from_path, spec)
     if spec.startswith("."):
         return _probe(modules, posixpath.join(posixpath.dirname(from_path), spec), lang)
     confs = sorted((c for c in modules.get("ts") or []
@@ -271,9 +299,10 @@ class Linker:
     parsed resolution configs (``code_index.parse_config``: ``{path, kind, data}``)."""
     facts: dict
     configs: list = field(default_factory=list)
+    roots: list = field(default_factory=list)      # the repositories of a folder indexed as one (module_index)
 
     def __post_init__(self):
-        self.modules = module_index(list(self.facts), self.configs)
+        self.modules = module_index(list(self.facts), self.configs, self.roots)
         self._defs: dict = {}
         self._pkgs: dict = {}                 # module key -> (files, names before the asked ones)
         self.ns: dict = {}                    # (family, package) -> files that declare it
@@ -586,10 +615,10 @@ class Linker:
             ret = next((b.imported for b in self.bindings(got[0])
                         if b.kind == "returns" and b.local_name == got[1] + _CALL and b.imported), None)
             if not ret:
-                return got
+                return None       # no declared return type: what ``.rest`` names is unproven (the call is its own ref)
             tp = [x for x in ret.split(".") if x]
             typed = self.resolve_ref(got[0], tp[0], ".".join(tp[1:] + rest), got[1], depth + 1)
-            return (typed[0], typed[1], "returns") if isinstance(typed, tuple) and typed[1] else got
+            return (typed[0], typed[1], "returns") if isinstance(typed, tuple) and typed[1] else None
         bound = [b for b in self.bindings(path) if b.local_name == head and b.kind != "star"]
         lang = _lang(path)
         if bound:
@@ -740,6 +769,8 @@ def impact(linker: Linker, symbols: list, depth: int = 2) -> dict:
                 if c not in it["callers"] and len(it["callers"]) < 20:
                     it["callers"].append(c)
             nk = (src, user)
+            if not user:              # a module-level use is no definition to follow -- never "the whole file"
+                continue
             if nk not in seen:
                 seen.add(nk)
                 nxt.append(nk)
@@ -778,6 +809,25 @@ def impact(linker: Linker, symbols: list, depth: int = 2) -> dict:
             same_file += [{"path": p, "user": user, "line": line} for src, user, _k, line, tp, tq, _o in links
                           if src == p and tp == p and tq == q and user != q][:20]
     out = sorted(items.values(), key=lambda i: (i["group"] == "tests", i["depth"], i["id"]))
+    resolved = [f"{p}::{q}" if q else p for p, q in targets]
     return {"ok": True, "data": {"items": out, "total": len(out), "has_more": False},
             "by_name_count": len(by_name_files), "by_name": by_name[:BY_NAME_SHOWN], "same_file": same_file,
-            "resolved": [f"{p}::{q}" if q else p for p, q in targets]}
+            "resolved": resolved,
+            "summary": impact_summary(symbols, resolved, len(out), len(by_name_files), len(same_file))}
+
+
+def impact_summary(symbols, resolved, users: int, by_name: int, same_file: int = 0) -> str:
+    """One sentence an agent cannot misread (report 06.11 #2: ``items: 0`` beside 11 name matches was read as "no
+    callers"): how many files use the symbol by resolved links, and what the name-only matches are -- unproven."""
+    what = ", ".join(str(s) for s in symbols or []) or "the symbol"
+    if not resolved:
+        return f"{what}: not a definition in this index -- nothing to trace (check the name or pass path::name)"
+    head = (f"{users} file(s) use {what} by resolved links" if users else f"no file uses {what} by a resolved link")
+    if same_file:
+        head += f"; {same_file} use(s) inside its own file"
+    if by_name:
+        head += (f"; {by_name} more file(s) only mention the name (by_name) -- calls through an untyped value or a "
+                 f"name clash: neither proven users nor proven unrelated, read them before concluding")
+    elif not users:
+        head += " and no other file mentions the name"
+    return head

imperal_sdk-6.5.2/tests/test_code_links.py

@@ -0,0 +1,170 @@
+"""imperal_sdk.code_links: the vault's link rules, computed locally (2026-11-06 report: a function with no caller
+answered 481 files when links were made by bare name)."""
+from __future__ import annotations
+
+import pytest
+
+pytest.importorskip("tree_sitter")
+pytest.importorskip("tree_sitter_python")
+
+from imperal_sdk import code_index as ci  # noqa: E402
+from imperal_sdk.code_links import Linker, impact, resolve_module, module_index  # noqa: E402
+
+
+def _linker(files: dict, configs: list | None = None) -> Linker:
+    return Linker({p: ci.scope_facts(p, t) for p, t in files.items()}, configs or [])
+
+
+PY = {
+    "pkg/__init__.py": "from .core import compute as compute_total\n",
+    "pkg/core.py": (
+        "def compute(x):\n    return helper(x)\n\n\ndef helper(x):\n    return x\n\n\n"
+        "def lonely():\n    return 1\n\n\nclass Cart:\n    def total(self):\n        return self.sum()\n\n"
+        "    def sum(self):\n        return 0\n"),
+    "app/use.py": "from pkg import compute_total\n\n\ndef run():\n    return compute_total(1)\n",
+    "app/deep.py": "from app.use import run\n\n\ndef outer():\n    return run()\n",
+    "app/other.py": "def go(obj):\n    return obj.lonely()\n\n\ndef unrelated():\n    return 2\n",
+    "tests/test_core.py": "from pkg.core import compute\n\n\ndef test_compute():\n    assert compute(2) == 2\n",
+}
+
+
+def test_a_function_nobody_calls_has_no_dependents():
+    out = impact(_linker(PY), ["lonely"])
+    assert out["data"]["items"] == [] and out["resolved"] == ["pkg/core.py::lonely"]
+    # obj.lonely() binds to nothing the resolver can prove: listed apart, by name only -- never a resolved link
+    assert [b["path"] for b in out["by_name"]] == ["app/other.py"] and out["by_name_count"] == 1
+
+
+def test_reexport_alias_and_depth_through_the_enclosing_def_only():
+    out = impact(_linker(PY), ["compute"], depth=2)
+    items = {i["id"]: i for i in out["data"]["items"]}
+    # pkg/__init__.py only re-exports (an import, no use): no user, as in the vault
+    assert set(items) == {"app/use.py", "tests/test_core.py", "app/deep.py"}
+    assert items["app/use.py"]["depth"] == 1 and items["app/use.py"]["user"] == "run"
+    assert items["app/deep.py"]["depth"] == 2 and items["app/deep.py"]["user"] == "outer"
+    assert "app/other.py" not in items                       # shares no link, never pulled in by a file's other defs
+    groups = [i["group"] for i in out["data"]["items"]]
+    assert groups == sorted(groups, key=lambda g: g == "tests")   # code before tests
+
+
+def test_self_member_and_same_file_users():
+    lk = _linker(PY)
+    assert lk.resolve_ref("pkg/core.py", "self", "sum", "Cart.total") == ("pkg/core.py", "Cart.sum", "self")
+    out = impact(lk, ["helper"])
+    assert out["data"]["items"] == [] and out["same_file"][0]["user"] == "compute"
+
+
+def test_unknown_symbol_is_said_not_scanned():
+    out = impact(_linker(PY), ["does_not_exist"])
+    assert out["resolved"] == [] and out["data"]["items"] == [] and out["by_name"] == []
+
+
+def test_qualified_forms():
+    lk = _linker(PY)
+    assert lk.symbol_targets("pkg/core.py::Cart.sum") == [("pkg/core.py", "Cart.sum")]
+    assert lk.symbol_targets("Cart.sum") == [("pkg/core.py", "Cart.sum")]
+    assert lk.symbol_targets("pkg/core.py") == [("pkg/core.py", "")]
+
+
+def test_typescript_paths_and_index():
+    pytest.importorskip("tree_sitter_typescript")
+    files = {
+        "tsconfig.json": "",
+        "src/lib/index.ts": "export function fmt(x: number) { return String(x) }\nexport function unused() { return 1 }\n",
+        "src/app.ts": "import { fmt } from '@/lib'\nexport function show() { return fmt(1) }\n",
+    }
+    facts = {p: ci.scope_facts(p, t) for p, t in files.items() if p.endswith(".ts")}
+    lk = Linker(facts, [{"path": "tsconfig.json", "kind": "tsconfig",
+                         "data": {"baseUrl": ".", "paths": {"@/*": ["src/*"]}}}])
+    assert [i["id"] for i in impact(lk, ["fmt"])["data"]["items"]] == ["src/app.ts"]
+    assert impact(lk, ["unused"])["data"]["items"] == []
+
+
+def test_resolve_module_is_the_vaults():
+    mods = module_index(["src/a/__init__.py", "src/a/b.py"], [])
+    assert resolve_module(mods, "src/a/__init__.py", ".b", "python") == "src/a/b.py"
+    assert resolve_module(mods, "x.py", "a.b", "python") == "src/a/b.py"
+    assert resolve_module(mods, "x.py", "requests", "python") is None
+
+
+FOLDER = {
+    "core/wpanel-sdk/pyproject.toml": '[project]\nname = "wpanel-sdk"\n[tool.setuptools.packages.find]\nwhere = ["src"]\n',
+    "core/wpanel-sdk/src/wpanel_sdk/__init__.py": "",
+    "core/wpanel-sdk/src/wpanel_sdk/ui/__init__.py": "class IRNode:\n    pass\n",
+    "modules/wpanel-tickets/wpanel_tickets/__init__.py": "",
+    "modules/wpanel-tickets/wpanel_tickets/screens.py": "from wpanel_sdk.ui import IRNode\n\n\ndef screen():\n"
+                                                        "    return IRNode()\n",
+    # two repos with the same top-level package name and no __init__ above it (namespace packages)
+    "gateway/app/sessions.py": "def session_for_sid(sid):\n    return sid\n",
+    "gateway/app/routes.py": "from app.sessions import session_for_sid\n\n\ndef me(sid):\n    return session_for_sid(sid)\n",
+    "billing/app/sessions.py": "def session_for_sid(sid):\n    return None\n",
+    "billing/app/api.py": "from app.sessions import session_for_sid\n\n\ndef pay(sid):\n    return session_for_sid(sid)\n",
+    "check-paths-agree.py": "print('IRNode')\n",
+}
+
+
+def _folder_linker(roots):
+    facts, configs = {}, []
+    for p, t in FOLDER.items():
+        if p.endswith(".toml"):
+            kind, data = ci.parse_config(p, t)
+            configs.append({"path": p, "kind": kind, "data": data})
+        else:
+            facts[p] = ci.scope_facts(p, t)
+    return Linker(facts, configs, roots)
+
+
+def test_a_folder_of_repositories_resolves_each_import_in_its_own_repository():
+    """06.11 #2: a folder indexed as one -- absolute imports from each repository's own root, a package another
+    repository provides by its name."""
+    lk = _folder_linker(["core/wpanel-sdk", "modules/wpanel-tickets", "gateway", "billing"])
+    assert [i["id"] for i in impact(lk, ["IRNode"])["data"]["items"]] == ["modules/wpanel-tickets/wpanel_tickets/screens.py"]
+    assert [i["id"] for i in impact(lk, ["gateway/app/sessions.py::session_for_sid"])["data"]["items"]] == \
+        ["gateway/app/routes.py"]
+    assert [i["id"] for i in impact(lk, ["billing/app/sessions.py::session_for_sid"])["data"]["items"]] == \
+        ["billing/app/api.py"]
+
+
+
+def test_the_summary_never_reads_as_no_callers_when_names_match():
+    out = impact(_linker(PY), ["lonely"])
+    assert out["data"]["items"] == [] and "no file uses lonely by a resolved link" in out["summary"]
+    assert "1 more file(s) only mention the name" in out["summary"] and "before concluding" in out["summary"]
+    assert impact(_linker(PY), ["compute"])["summary"].startswith("3 file(s) use compute by resolved links")
+    assert "not a definition" in impact(_linker(PY), ["nope"])["summary"]
+
+
+def test_python_members_through_typed_locals_fields_and_returns():
+    lk = _linker({
+        "repo.py": "class Repo:\n    def save(self):\n        return 1\n\n\ndef make_repo() -> 'Repo':\n    return Repo()\n\n\n"
+                   "def open_repo() -> Repo:\n    return Repo()\n",
+        "svc.py": "from typing import Optional\nfrom repo import Repo, open_repo\n\n\nclass Svc:\n"
+                  "    def __init__(self, repo: Repo):\n        self.repo = repo\n\n    def run(self):\n"
+                  "        return self.repo.save()\n\n\ndef a():\n    r = Repo()\n    return r.save()\n\n\n"
+                  "def b(r: Optional[Repo]):\n    return r.save()\n\n\ndef c():\n    r = open_repo()\n    return r.save()\n\n\n"
+                  "def d(x):\n    return x.save()\n",
+    })
+    got = impact(lk, ["Repo.save"])
+    users = {c["user"] for i in got["data"]["items"] for c in i["callers"]}
+    assert users == {"Svc.run", "a", "b", "c"}             # d's x is untyped: by name only, never a resolved link
+    assert got["by_name"] == [] or all(b["path"] != "svc.py" for b in got["by_name"])
+
+
+
+def test_a_member_of_an_unannotated_call_result_is_never_linked_to_the_call():
+    """A spot check of real links found ``vs.to_arrays()`` linked to ``VectorStore.from_arrays`` (vs came from it)."""
+    lk = _linker({"v.py": "class VectorStore:\n    @classmethod\n    def from_arrays(cls, a):\n        return cls()\n\n"
+                          "    def to_arrays(self):\n        return 1\n",
+                  "u.py": "from v import VectorStore\n\n\ndef go():\n    vs = VectorStore.from_arrays(1)\n"
+                          "    return vs.to_arrays()\n"})
+    got = {(l[3], l[5]) for l in lk.links() if l[0] == "u.py"}
+    assert (5, "VectorStore.from_arrays") in got and (6, "VectorStore.from_arrays") not in got
+
+
+
+def test_depth_never_grows_through_a_module_level_use_as_the_whole_file():
+    lk = _linker({"q.py": "def linker():\n    return 1\n",
+                  "mod.py": "from q import linker\nVALUE = linker()\n\n\ndef unrelated():\n    return 2\n",
+                  "uses_mod.py": "from mod import unrelated\n\n\ndef f():\n    return unrelated()\n"})
+    got = {(i["id"], i["depth"]) for i in impact(lk, ["linker"], depth=2)["data"]["items"]}
+    assert got == {("mod.py", 1)}                      # uses_mod.py only uses another definition of mod.py

imperal_sdk-6.5.0/tests/test_code_links.py

@@ -1,87 +0,0 @@
-"""imperal_sdk.code_links: the vault's link rules, computed locally (2026-11-06 report: a function with no caller
-answered 481 files when links were made by bare name)."""
-from __future__ import annotations
-
-import pytest
-
-pytest.importorskip("tree_sitter")
-pytest.importorskip("tree_sitter_python")
-
-from imperal_sdk import code_index as ci  # noqa: E402
-from imperal_sdk.code_links import Linker, impact, resolve_module, module_index  # noqa: E402
-
-
-def _linker(files: dict, configs: list | None = None) -> Linker:
-    return Linker({p: ci.scope_facts(p, t) for p, t in files.items()}, configs or [])
-
-
-PY = {
-    "pkg/__init__.py": "from .core import compute as compute_total\n",
-    "pkg/core.py": (
-        "def compute(x):\n    return helper(x)\n\n\ndef helper(x):\n    return x\n\n\n"
-        "def lonely():\n    return 1\n\n\nclass Cart:\n    def total(self):\n        return self.sum()\n\n"
-        "    def sum(self):\n        return 0\n"),
-    "app/use.py": "from pkg import compute_total\n\n\ndef run():\n    return compute_total(1)\n",
-    "app/deep.py": "from app.use import run\n\n\ndef outer():\n    return run()\n",
-    "app/other.py": "def go(obj):\n    return obj.lonely()\n\n\ndef unrelated():\n    return 2\n",
-    "tests/test_core.py": "from pkg.core import compute\n\n\ndef test_compute():\n    assert compute(2) == 2\n",
-}
-
-
-def test_a_function_nobody_calls_has_no_dependents():
-    out = impact(_linker(PY), ["lonely"])
-    assert out["data"]["items"] == [] and out["resolved"] == ["pkg/core.py::lonely"]
-    # obj.lonely() binds to nothing the resolver can prove: listed apart, by name only -- never a resolved link
-    assert [b["path"] for b in out["by_name"]] == ["app/other.py"] and out["by_name_count"] == 1
-
-
-def test_reexport_alias_and_depth_through_the_enclosing_def_only():
-    out = impact(_linker(PY), ["compute"], depth=2)
-    items = {i["id"]: i for i in out["data"]["items"]}
-    # pkg/__init__.py only re-exports (an import, no use): no user, as in the vault
-    assert set(items) == {"app/use.py", "tests/test_core.py", "app/deep.py"}
-    assert items["app/use.py"]["depth"] == 1 and items["app/use.py"]["user"] == "run"
-    assert items["app/deep.py"]["depth"] == 2 and items["app/deep.py"]["user"] == "outer"
-    assert "app/other.py" not in items                       # shares no link, never pulled in by a file's other defs
-    groups = [i["group"] for i in out["data"]["items"]]
-    assert groups == sorted(groups, key=lambda g: g == "tests")   # code before tests
-
-
-def test_self_member_and_same_file_users():
-    lk = _linker(PY)
-    assert lk.resolve_ref("pkg/core.py", "self", "sum", "Cart.total") == ("pkg/core.py", "Cart.sum", "self")
-    out = impact(lk, ["helper"])
-    assert out["data"]["items"] == [] and out["same_file"][0]["user"] == "compute"
-
-
-def test_unknown_symbol_is_said_not_scanned():
-    out = impact(_linker(PY), ["does_not_exist"])
-    assert out["resolved"] == [] and out["data"]["items"] == [] and out["by_name"] == []
-
-
-def test_qualified_forms():
-    lk = _linker(PY)
-    assert lk.symbol_targets("pkg/core.py::Cart.sum") == [("pkg/core.py", "Cart.sum")]
-    assert lk.symbol_targets("Cart.sum") == [("pkg/core.py", "Cart.sum")]
-    assert lk.symbol_targets("pkg/core.py") == [("pkg/core.py", "")]
-
-
-def test_typescript_paths_and_index():
-    pytest.importorskip("tree_sitter_typescript")
-    files = {
-        "tsconfig.json": "",
-        "src/lib/index.ts": "export function fmt(x: number) { return String(x) }\nexport function unused() { return 1 }\n",
-        "src/app.ts": "import { fmt } from '@/lib'\nexport function show() { return fmt(1) }\n",
-    }
-    facts = {p: ci.scope_facts(p, t) for p, t in files.items() if p.endswith(".ts")}
-    lk = Linker(facts, [{"path": "tsconfig.json", "kind": "tsconfig",
-                         "data": {"baseUrl": ".", "paths": {"@/*": ["src/*"]}}}])
-    assert [i["id"] for i in impact(lk, ["fmt"])["data"]["items"]] == ["src/app.ts"]
-    assert impact(lk, ["unused"])["data"]["items"] == []
-
-
-def test_resolve_module_is_the_vaults():
-    mods = module_index(["src/a/__init__.py", "src/a/b.py"], [])
-    assert resolve_module(mods, "src/a/__init__.py", ".b", "python") == "src/a/b.py"
-    assert resolve_module(mods, "x.py", "a.b", "python") == "src/a/b.py"
-    assert resolve_module(mods, "x.py", "requests", "python") is None