graphite-code 1.3.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

graphite/__init__.py

@@ -38,4 +38,4 @@ __all__ = ["__version__"]
 #: Coarse and hand-maintained by construction. It is a release label, not
 #: evidence that a given fix is present -- to answer that, survey for the marker
 #: the fix introduced, or compare `graphite --version` fingerprints.
-__version__ = "1.3.0"
+__version__ = "1.4.0"

graphite/agent_hooks.py

@@ -968,6 +968,54 @@ def _forget_what_may_be_set_again(assigned: dict[str, str], argv: list[str], pow
             assigned.pop(named.group().lower() if powershell else named.group(), None)
 
 
+# PowerShell commands whose output is the files (or folders) of a path, so that a
+# `Select-String` after a pipe searches what they hand it (#84).
+_FILE_LISTINGS = frozenset({"get-childitem", "gci", "ls", "dir"})
+# The searches that take files from the pipeline. `grep` does not: it reads the
+# lines of what is piped, so `ls | grep name` filters a list of names.
+_POWERSHELL_SEARCHES = frozenset({"select-string", "sls"})
+# What may stand between such a listing and the search and still hand the search
+# files: a stage that only keeps or orders them. Any other stage (`ForEach-Object`,
+# `Out-String`, `Select-Object -ExpandProperty`) may make text, and ends the chain.
+_FILE_KEEPING_STAGES = frozenset({
+    "where-object", "where", "?", "select-object", "select", "sort-object", "sort",
+})
+# Listing flags that take a word, so the word is not a path. `-Path` and
+# `-LiteralPath` are the exceptions: their word IS one.
+_LISTING_VALUE_FLAGS = frozenset({
+    "-filter", "-include", "-exclude", "-depth", "-attributes",
+})
+_LISTING_PATH_FLAGS = frozenset({"-path", "-literalpath"})
+
+
+def _listed_paths(name: str, rest: list[str]) -> list[str] | None:
+    """The paths a file listing names, else None where `name` lists no files.
+
+    An empty list is a listing of the current directory. `-Name` makes the
+    listing text, and what is piped on is then a filter of it.
+    """
+    if name not in _FILE_LISTINGS:
+        return None
+    paths: list[str] = []
+    expecting = False
+    skipping = False
+    for token in rest:
+        lowered = token.lower()
+        if expecting or skipping:
+            if expecting:
+                paths.append(token)
+            expecting = skipping = False
+        elif lowered == "-name" or lowered == "-n":
+            return None
+        elif lowered in _LISTING_PATH_FLAGS:
+            expecting = True
+        elif lowered in _LISTING_VALUE_FLAGS:
+            skipping = True
+        elif not token.startswith("-"):
+            paths.append(token)
+    return paths
+
+
 def _bash_searches(
     command: str, root: Path, msys: bool = False, cwd: Path | None = None, powershell: bool = False
 ) -> list[_Search]:
@@ -1024,9 +1072,11 @@ def _bash_searches(
         base, placed = start, start_placed  # `base` is where the shell is
         moved = False  # a `cd`, or a command the hook does not model, has run in this shell
         pipeline_base, pipeline_placed = base, placed  # where the pipeline being read started
+        listed: list[str] | None = None  # the paths of the file listing whose output the stage before gives
         for head in _bash_command_heads(lines, powershell):
             piped = head.before in ("|", "|&")  # `||` is or-else, not a pipe
             if not piped:
+                listed = None
                 if head.before != "&&":
                     base, placed = (None, False) if moved else (start, start_placed)
                 pipeline_base, pipeline_placed = base, placed
@@ -1040,6 +1090,16 @@ def _bash_searches(
             if len(head.argv) == 1 and _NESTED_RE.fullmatch(head.argv[0]):
                 continue  # a subshell standing alone
             if piped and _command_name(head.argv[0]) != "xargs":
+                stage = _command_name(head.argv[0])
+                if listed is not None and stage in _POWERSHELL_SEARCHES:
+                    # `Get-ChildItem -Recurse src | Select-String name` searches
+                    # the files it is handed (#84), as `xargs grep` does.
+                    found = _search_in(stage, [_expanded(t, assigned, powershell) for t in head.argv[1:]], here, msys)
+                    if found is not None:
+                        found = found._replace(paths=_located(listed, here, msys))
+                        searches.append(found if here_placed or cwd is None else _unplaced(found, cwd))
+                if stage not in _FILE_KEEPING_STAGES:
+                    listed = None
                 continue  # a filter: it reads what the command before it wrote
             assignments = _assignments(head.argv, powershell)
             if assignments is not None:
@@ -1063,6 +1123,7 @@ def _bash_searches(
                 continue
             name = _command_name(argv[0])
             rest = [_expanded(token, assigned, powershell) for token in argv[1:]]
+            listed = _listed_paths(name, rest) if len(argv) == len(written) else None
             # A `cd` behind a wrapper is not the shell's: `env cd docs` moves a
             # program that then exits, and `! cd docs && ...` goes on only when
             # the `cd` failed. It is read below, as a command that may move.

graphite/cli.py

@@ -255,12 +255,17 @@ def _write_json(path: Path, data: dict[str, Any]) -> None:
     atomic_write_json(path, data, indent=2)
 
 
-def _scan(args: argparse.Namespace, cfg: Config) -> tuple[dict[str, Any], list[Any]]:
-    cfg = cfg.canonical_graph()
-    root = Path(args.path).resolve()
+def _require_existing(root: Path) -> None:
+    """Exit 1 with `path not found` for a path that is not there."""
     if not root.exists():
         print(f"[graphite] path not found: {root}", file=sys.stderr)
         raise SystemExit(1)
+
+
+def _scan(args: argparse.Namespace, cfg: Config) -> tuple[dict[str, Any], list[Any]]:
+    cfg = cfg.canonical_graph()
+    root = Path(args.path).resolve()
+    _require_existing(root)
     top = _root_above(root)
     if top is not None:
         raise ValueError(_below_a_root(root, top))
@@ -727,6 +732,9 @@ def cmd_build(args: argparse.Namespace) -> int:
     top = _root_above(asked)
     if top is not None:
         raise ValueError(_below_a_root(asked, top))
+    # A path that is not there is refused as `scan` refuses it (#88): the lock
+    # below would otherwise make it, and a detached child could not start in it.
+    _require_existing(asked)
     if getattr(args, "detach", False):
         root = Path(args.path).resolve()
         # Deliberately omits --detach: the child must build, not re-spawn.
@@ -839,6 +847,10 @@ def cmd_doctor(args: argparse.Namespace) -> int:
     root = Path(args.path).resolve()
     if not root.is_dir():
         raise ValueError("doctor path must be an existing directory")
+    # The report is about the repository the folder is in (#89), as the read
+    # commands are: from a subfolder the graph is the root's, and so are the
+    # incidents. A root graphite does not take (`repository_root`) is not followed.
+    root = repository_root(root)
     cfg = _project_scoped_config(args, root)
     report = run_doctor(
         root,
@@ -1204,6 +1216,11 @@ def cmd_init(args: argparse.Namespace) -> int:
             extra += f", reason={hooks['reason']}"
         if hooks.get("relocated"):
             extra += f", relocated={', '.join(hooks['relocated'])}"
+        if hooks.get("chain_slots"):
+            # Said in either install order: with graphite first nothing is in
+            # these slots yet, and this is where another tool's hook goes.
+            files = ", ".join(slot["file"] for slot in hooks["chain_slots"].values())
+            extra += f"; another tool's hook for the same event belongs in {files} there, run first"
         print(f"  - hooks: {hooks.get('action')} ({hooks.get('path')}{extra})")
         allowlist = result["allowlist"]
         if allowlist.get("changed"):

graphite/doctor.py

@@ -20,7 +20,7 @@ from .daemon import read_daemon_status
 from .daemon_health import HealthOptions, evaluate_daemon_health
 from .freshness import FreshnessLimitError, check_graph_freshness
 from .git import GitError, GitRunner
-from .hookinstall import DEFAULT_HOOKS_DIRNAME, hook_shim_present, hooks_dir
+from .hookinstall import DEFAULT_HOOKS_DIRNAME, chain_slots, hook_shim_present, hooks_dir
 from .init import gitignored_managed_paths, managed_doc_paths
 from .hookshim import TRIGGERS
 from .llm import canonical_provider_name
@@ -179,7 +179,7 @@ def check_hooks(root: Path) -> DoctorCheck:
     installed = all(hook_shim_present(hdir / hook) for hook in TRIGGERS)
     configured = _hooks_path_configured(root)
     custom_hooks_dir = hdir != root / DEFAULT_HOOKS_DIRNAME
-    details = {"onboarded": True, "custom_hooks_dir": custom_hooks_dir, "hookspath_configured": configured, "trampolines_installed": installed}
+    details = {"onboarded": True, "custom_hooks_dir": custom_hooks_dir, "hookspath_configured": configured, "trampolines_installed": installed, "chain_slots": chain_slots(hdir)}
 
     if configured and installed:
         return DoctorCheck("hooks", "Hooks", "ready", "Git hooks are installed and enforced.", details)

graphite/extract/ast.py

@@ -6,9 +6,10 @@ import importlib
 import re
 import sys
 import unicodedata
+import dataclasses
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Collection, Final, Sequence
+from typing import Any, Collection, Final, Iterable, Sequence
 
 from ..cache import Cache
 from ..config import Config
@@ -214,8 +215,10 @@ def _make_id(*parts: str) -> str:
     Known residual: two DIFFERENT part tuples can still produce one id when the
     only difference is a separator versus a literal underscore — `a/b.py` and
     `a_b.py` both reach `a_b_py`, and both are ambiguity-free by this test.
-    Closing it would mean discriminating every path containing an underscore,
-    which is most of `tests/`. Measured occurrences in this repo: zero.
+    Closing it here would mean discriminating every path containing an
+    underscore, which is most of `tests/`. For FILE ids it is closed another
+    way (#82): `_colliding_file_ids` marks the paths of a tree that actually
+    collide and no others. For a definition's id within one file it remains.
     """
     kept = [p for p in parts if p]
     combined = unicodedata.normalize("NFKC", "_".join(p.strip("_.") for p in kept))
@@ -262,7 +265,52 @@ def _scoped_id(file_id: str, qualname: str, salt: int = 0) -> str:
     return f"{readable[: _MAX_ID_LEN - len(marker) - 1].rstrip('_')}_{marker}"
 
 
-def _file_node_id(rel_path: str) -> str:
+def _file_node_id(rel_path: str, source_index: SourceIndex | None = None) -> str:
+    """The id of a file's node: its plain id, or the one the tree gave it (#82).
+
+    A path whose plain id another path of the tree also has is given a marker
+    by `_colliding_file_ids`, which `extract_all` records on the source index.
+    Everything else keeps its plain id.
+    """
+    if source_index is not None and source_index.file_ids:
+        marked = source_index.file_ids.get(rel_path)
+        if marked is not None:
+            return marked
+    return _plain_file_node_id(rel_path)
+
+
+def _colliding_file_ids(rel_paths: Iterable[str]) -> dict[str, str]:
+    """rel path -> file node id, for each path whose plain id another path has.
+
+    `a/b.py`, `a_b.py` and `a/b_py` all slug to `a_b_py`, a loss `_make_id`
+    cannot see from one path. Every member of such a group is marked, with a
+    hash of its own exact path, so no id depends on which of them is listed
+    first or on whether the others are still there. A path that collides with
+    nothing is not in the result: ids of files without a twin do not move.
+    """
+    groups: dict[str, list[str]] = {}
+    for rel_path in rel_paths:
+        groups.setdefault(_plain_file_node_id(rel_path), []).append(rel_path)
+    taken = set(groups)
+    marked: dict[str, str] = {}
+    for plain, members in sorted(groups.items()):
+        if len(members) < 2:
+            continue
+        for rel_path in sorted(members):
+            salt = 0
+            while True:
+                tag = f"file-path\x00{rel_path}" + (f"\x00{salt}" if salt else "")
+                marker = hashlib.blake2s(tag.encode("utf-8"), digest_size=_ID_DISCRIMINATOR_LEN // 2).hexdigest()
+                candidate = f"{plain[: _MAX_ID_LEN - len(marker) - 1].rstrip('_')}_{marker}"
+                if candidate not in taken:
+                    break
+                salt += 1
+            taken.add(candidate)
+            marked[rel_path] = candidate
+    return marked
+
+
+def _plain_file_node_id(rel_path: str) -> str:
     """Stable node id for a file: a slug of the FULL repo-relative path AND name.
 
     Two claims this docstring used to make were false, and both were disproved
@@ -396,7 +444,7 @@ def _extract_ts_js(file_id: str, rel_path: str, source: bytes, tree: Any, source
     root = tree.root_node
 
     def _line(node: Any) -> int:
-        return (node.start_point[0] + 1) if node.start_point else 1
+        return node.start_point[0] + 1
 
     def _name(node: Any) -> str | None:
         # identifiers, property_identifier, type_identifier, etc.
@@ -424,7 +472,7 @@ def _extract_ts_js(file_id: str, rel_path: str, source: bytes, tree: Any, source
     def _anon_scope(node: Any) -> _Scope:
         syn = _safe_label(_synthetic_fn_name(node, source))
         line = _line(node)
-        col = (node.start_point[1] + 1) if node.start_point else 1
+        col = node.start_point[1] + 1
         mid = _make_id(file_id, syn, f"l{line}", f"c{col}")
         pending = _node(mid, "function", syn, rel_path, line, extra={"anonymous": True})
         return _Scope(mid, pending=pending)
@@ -517,7 +565,7 @@ def _extract_ts_js(file_id: str, rel_path: str, source: bytes, tree: Any, source
                     result.edges.append(
                         _edge(
                             file_id,
-                            _file_node_id(resolved.rel_path),
+                            _file_node_id(resolved.rel_path, source_index),
                             "imports",
                             rel_path,
                             _line(node),
@@ -540,7 +588,7 @@ def _extract_ts_js(file_id: str, rel_path: str, source: bytes, tree: Any, source
                     result.edges.append(
                         _edge(
                             file_id,
-                            _file_node_id(required.rel_path),
+                            _file_node_id(required.rel_path, source_index),
                             "imports",
                             rel_path,
                             _line(node),
@@ -646,7 +694,7 @@ def _extract_ts_js(file_id: str, rel_path: str, source: bytes, tree: Any, source
             result.edges.append(
                 _edge(
                     file_id,
-                    _file_node_id(edge.target),
+                    _file_node_id(edge.target, source_index),
                     edge.relation,
                     rel_path,
                     edge.line,
@@ -724,7 +772,7 @@ def _collect_ts_import_symbols(root: Any, rel_path: str, source_index: SourceInd
         # Resolved module: every name it binds is proven in-repo, regardless
         # of binding form -- must win over an _EXTERNAL_GLOBALS collision.
         in_repo.update(_iter_bound_local_names(clause))
-        target_file_id = _file_node_id(resolved.rel_path)
+        target_file_id = _file_node_id(resolved.rel_path, source_index)
         for local, original in _iter_named_imports(clause):
             symbols[local] = _make_id(target_file_id, original)
         for child in clause.children:
@@ -766,7 +814,7 @@ def _collect_ts_import_symbols(root: Any, rel_path: str, source_index: SourceInd
             external.update(bound)
             return
         in_repo.update(bound)
-        target_file_id = _file_node_id(resolved.rel_path)
+        target_file_id = _file_node_id(resolved.rel_path, source_index)
         if pairs:
             for local, original in pairs:
                 symbols[local] = _make_id(target_file_id, original)
@@ -1314,7 +1362,7 @@ def _python_import_bindings(
                     out.append((root, "unknown", None))
                 elif "." not in module:
                     resolved = source_index.resolve_python_module(rel_path, module)
-                    out.append((module, "alias", _file_node_id(resolved)) if resolved else (module, "external", None))
+                    out.append((module, "alias", _file_node_id(resolved, source_index)) if resolved else (module, "external", None))
                 elif source_index.resolve_python_module(rel_path, root) is None:
                     # `import pkg.sub` binds only the root name `pkg`. Mark it
                     # external ONLY if that root does not resolve in-repo -- a
@@ -1331,7 +1379,7 @@ def _python_import_bindings(
                     out.append((local, "unknown", None))
                     continue
                 resolved = source_index.resolve_python_module(rel_path, module)
-                out.append((local, "alias", _file_node_id(resolved)) if resolved else (local, "external", None))
+                out.append((local, "alias", _file_node_id(resolved, source_index)) if resolved else (local, "external", None))
     elif node.type == "import_from_statement":
         modules = _python_import_modules(node)
         if not modules:
@@ -1359,11 +1407,14 @@ def _python_import_bindings(
             sub = f"{base_module}.{original}" if base_module else original
             as_module = source_index.resolve_python_module(rel_path, sub, dots)
             if as_module:
-                out.append((local, "alias", _file_node_id(as_module)))
+                out.append((local, "alias", _file_node_id(as_module, source_index)))
                 continue
             parent = source_index.resolve_python_module(rel_path, base_module, dots)
             if parent:
-                out.append((local, "symbol", _make_id(_file_node_id(parent), original)))
+                # A package that only re-exports the name does not define it:
+                # bind to the file that does (#87).
+                defining, defined_as = source_index.follow_python_reexport(parent, original)
+                out.append((local, "symbol", _make_id(_file_node_id(defining, source_index), defined_as)))
             else:
                 out.append((local, "external", None))
     return out
@@ -1459,6 +1510,9 @@ def _python_bare_call(
         return ids[(resolution.qualname, resolution.module_level)], confidence
     if resolution.kind == "symbol" and resolution.target is not None:
         return resolution.target, confidence
+    if resolution.kind == "member" and resolution.target is not None and resolution.qualname is not None:
+        # `t = mod.attr; t()`: the call `mod.attr()` makes (#90).
+        return _make_id(resolution.target, resolution.qualname), confidence
     if resolution.kind in ("value", "alias", "ambiguous-import") and table.module_defines(name):
         return ids[(f"<local>.{name}", False)], confidence
     return _resolve_call(file_id, name), confidence
@@ -1510,7 +1564,7 @@ def _extract_python(file_id: str, rel_path: str, _source: bytes, tree: Any, sour
     root = tree.root_node
 
     def _line(node: Any) -> int:
-        return (node.start_point[0] + 1) if node.start_point else 1
+        return node.start_point[0] + 1
 
     result.nodes.append(_node(file_id, "file", Path(rel_path).name, rel_path))
 
@@ -1582,7 +1636,15 @@ def _extract_python(file_id: str, rel_path: str, _source: bytes, tree: Any, sour
                     for arg in base.children:
                         if arg.type.endswith("identifier") and arg.text:
                             base_name = arg.text.decode("utf-8", errors="ignore")
-                            result.edges.append(_edge(did, _make_id(base_name), "inherits", rel_path, _line(arg)))
+                            base_target = _make_id(base_name)
+                            if body_scope is not None and body_scope.parent is not None:
+                                # Where the source states which class the name
+                                # is, the edge ends at that class (#86); any
+                                # other base keeps its placeholder.
+                                named = resolve(body_scope.parent, base_name)
+                                if named.kind in ("def", "symbol"):
+                                    base_target = _python_definition_id(named, ids) or base_target
+                            result.edges.append(_edge(did, base_target, "inherits", rel_path, _line(arg)))
             walk_children(node, did, scope_id)
         elif node.type in ("import_statement", "import_from_statement"):
             for module, dots in _python_import_modules(node):
@@ -1593,7 +1655,7 @@ def _extract_python(file_id: str, rel_path: str, _source: bytes, tree: Any, sour
                 )
                 if resolved:
                     result.edges.append(_edge(
-                        file_id, _file_node_id(resolved), "imports", rel_path,
+                        file_id, _file_node_id(resolved, source_index), "imports", rel_path,
                         _line(node), confidence="EXACT_IMPORT",
                     ))
                     # `import pkg.sub` also imports `pkg` (#55). Deliberately NOT
@@ -1606,7 +1668,7 @@ def _extract_python(file_id: str, rel_path: str, _source: bytes, tree: Any, sour
                         if node.type == "import_statement" else ()
                     ):
                         result.edges.append(_edge(
-                            file_id, _file_node_id(ancestor), "imports", rel_path,
+                            file_id, _file_node_id(ancestor, source_index), "imports", rel_path,
                             _line(node), confidence="EXACT_IMPORT",
                         ))
                 else:
@@ -1616,7 +1678,7 @@ def _extract_python(file_id: str, rel_path: str, _source: bytes, tree: Any, sour
                     ))
             for sub in _python_from_import_submodules(node, rel_path, source_index):
                 result.edges.append(_edge(
-                    file_id, _file_node_id(sub), "imports", rel_path,
+                    file_id, _file_node_id(sub, source_index), "imports", rel_path,
                     _line(node), confidence="EXACT_IMPORT",
                 ))
             walk_children(node, parent_id, scope_id)
@@ -1628,8 +1690,14 @@ def _extract_python(file_id: str, rel_path: str, _source: bytes, tree: Any, sour
             bare, obj_name, attr = _python_call_target(func) if func is not None else (None, None, None)
             edge = None
             scope = table.scope_of_call(node)
-            if bare and bare not in _LANGUAGE_BUILTIN_GLOBALS:
-                resolution = resolve(scope, bare)
+            # The list holds the builtins of every language, so a name on it is
+            # left without an edge only where the file binds nothing by that
+            # name: a class `Error` or a function `make` of this file or one it
+            # imports is called like any other (#85).
+            resolution = resolve(scope, bare) if bare else None
+            if bare and resolution is not None and (
+                bare not in _LANGUAGE_BUILTIN_GLOBALS or resolution.kind != "none"
+            ):
                 target, confidence = _python_bare_call(file_id, bare, resolution, table, ids)
                 edge = _edge(scope_id, target, "calls", rel_path, _line(node), confidence=confidence)
             elif attr:
@@ -1716,7 +1784,7 @@ def _extract_go(file_id: str, rel_path: str, source: bytes, tree: Any) -> Extrac
     root = tree.root_node
 
     def _line(node: Any) -> int:
-        return (node.start_point[0] + 1) if node.start_point else 1
+        return node.start_point[0] + 1
 
     def _text(node: Any) -> str | None:
         return node.text.decode("utf-8", errors="ignore") if node is not None and node.text else None
@@ -1814,7 +1882,7 @@ def _extract_rust(
     root = tree.root_node
 
     def _line(node: Any) -> int:
-        return (node.start_point[0] + 1) if node.start_point else 1
+        return node.start_point[0] + 1
 
     def _text(node: Any) -> str | None:
         return node.text.decode("utf-8", errors="ignore") if node is not None and node.text else None
@@ -1887,7 +1955,7 @@ def _extract_rust(
                         result.edges.append(
                             _edge(
                                 file_id,
-                                _file_node_id(resolved),
+                                _file_node_id(resolved, source_index),
                                 "imports",
                                 rel_path,
                                 _line(node),
@@ -1913,7 +1981,7 @@ def _extract_rust(
                         result.edges.append(
                             _edge(
                                 file_id,
-                                _file_node_id(resolution.rel_path),
+                                _file_node_id(resolution.rel_path, source_index),
                                 "imports",
                                 rel_path,
                                 _line(node),
@@ -2058,6 +2126,18 @@ def extract_file(entry: FileEntry, cfg: Config, cache: Cache | None = None, sour
         # Only resolver-consulting languages pay this invalidation: Go and Rust
         # extraction is file-local and cannot go stale this way.
         cache_language = f"{cache_language}:fs{source_index.file_set_digest()}"
+        if entry.language == "python":
+            # A name imported through a package is bound to the file the
+            # package's `__init__.py` re-exports it from, and that file's bytes
+            # are not the importer's (#87).
+            cache_language = f"{cache_language}:rx{source_index.python_reexport_digest()}"
+    if source_index is not None and source_index.file_ids:
+        # A file node id is the plain one unless another path shares it, and an
+        # import edge names its target by that id; so a cached extraction is
+        # good only for the same set of marked ids (#82). A tree with no such
+        # pair adds nothing here, and its keys are what they were.
+        marked = "\0".join(f"{path}\0{file_id}" for path, file_id in sorted(source_index.file_ids.items()))
+        cache_language = f"{cache_language}:fid{hashlib.blake2s(marked.encode('utf-8'), digest_size=8).hexdigest()}"
     # What is cached names the file: every node id and `source_file` in it is
     # built from the path. Keyed on the bytes and the language alone, two files
     # with the same bytes shared one entry, so one of them was answered with
@@ -2070,7 +2150,7 @@ def extract_file(entry: FileEntry, cfg: Config, cache: Cache | None = None, sour
             return _result_from_dict(cached)
 
     rel_path = entry.rel_path
-    file_id = _file_node_id(rel_path)
+    file_id = _file_node_id(rel_path, source_index)
 
     try:
         with open(entry.abs_path, "rb") as f:
@@ -2134,6 +2214,9 @@ def extract_all(entries: list[FileEntry], cfg: Config, cache: Cache | None = Non
     results: list[ExtractionResult] = []
     error_records: list[dict[str, Any]] = []
     source_index = SourceIndex.from_entries(entries, cfg)
+    file_ids = _colliding_file_ids(entry.rel_path for entry in entries)
+    if file_ids:
+        source_index = dataclasses.replace(source_index, file_ids=file_ids)
     if cfg.workers <= 1:
         for entry in entries:
             result = extract_file(entry, cfg, cache, source_index)
@@ -2627,8 +2710,17 @@ def _resolve_method_dispatch(
     # Which file each definition lives in, and which files each file imports
     # DIRECTLY. Both are needed to answer "could this caller have reached that
     # definition at all" -- see the reachability filter below (#54).
+    # The id a path's file node was given is read off that node: a path whose
+    # plain id another path has was given another (#82).
+    file_node_of_path: dict[str, str] = {
+        n["source_file"]: n["id"] for n in nodes if n.get("kind") == "file" and n.get("source_file")
+    }
+
+    def file_node_id_of(path: str) -> str:
+        return file_node_of_path.get(path) or _file_node_id(path)
+
     file_of_node: dict[str, str] = {
-        n["id"]: _file_node_id(n["source_file"]) for n in nodes if n.get("source_file")
+        n["id"]: file_node_id_of(n["source_file"]) for n in nodes if n.get("source_file")
     }
     # Which interop family each definition belongs to, for the family gate below.
     family_of_node: dict[str, str | None] = {
@@ -2733,7 +2825,7 @@ def _resolve_method_dispatch(
         # reachable definition now resolves instead of being abandoned as
         # "too generic to guess".
         if candidates and _dispatch_is_gated(e.get("source_file")):
-            caller_file = _file_node_id(e["source_file"])
+            caller_file = file_node_id_of(e["source_file"])
             reachable: set[str] | frozenset[str] = imports_by_file.get(caller_file, frozenset())
             in_file = methods_by_name_and_file[name]
             candidates = {

graphite/extract/pyscope.py

@@ -112,7 +112,8 @@ class PyScope:
 class Resolution:
     """What a bare name denotes at one call site."""
 
-    kind: str  # "def" | "symbol" | "alias" | "external" | "ambiguous-import" | "value" | "none"
+    #: "member" is `qualname`, an attribute of the in-repo module file `target` (#90).
+    kind: str  # "def" | "symbol" | "alias" | "member" | "external" | "ambiguous-import" | "value" | "none"
     qualname: str | None = None
     module_level: bool = False
     target: str | None = None
@@ -211,6 +212,25 @@ def _value_origin(node: Any) -> tuple[str, str] | None:
     return None
 
 
+def _alias_origin(node: Any) -> tuple[str, str] | None:
+    """("name", text) for a bare name, ("attr", "obj.attr") for one attribute of a name.
+
+    What an assignment of such an expression binds is the thing the expression
+    names, so a call of the new name is a call of that thing (#90). Anything
+    longer (`a.b.c`, `f().x`, a subscript) says too little and gives None.
+    """
+    node = _unparenthesized(node)
+    if node is None:
+        return None
+    if node.type == "identifier":
+        return ("name", _text(node))
+    if node.type == "attribute":
+        obj, attr = node.child_by_field_name("object"), node.child_by_field_name("attribute")
+        if obj is not None and obj.type == "identifier" and attr is not None:
+            return ("attr", f"{_text(obj)}.{_text(attr)}")
+    return None
+
+
 def _value_binder(value: Any, scope: PyScope, handed_over: bool = False) -> Binder:
     """The binder of a name one statement binds to `value`, evaluated in `scope`.
 
@@ -219,7 +239,8 @@ def _value_binder(value: Any, scope: PyScope, handed_over: bool = False) -> Bind
     """
     origin = _value_origin(value)
     if origin is None:
-        return _VALUE
+        alias = None if handed_over else _alias_origin(value)
+        return _VALUE if alias is None else Binder("value", origin=(alias[0], alias[1], scope))
     how, name = origin
     return Binder("value", origin=("with" if handed_over and how == "call" else how, name, scope))
 
@@ -599,20 +620,44 @@ def resolving_scope(scope: PyScope, name: str) -> PyScope | None:
     return None
 
 
-def resolve(scope: PyScope, name: str) -> Resolution:
+def resolve(scope: PyScope, name: str, _following: frozenset[int] = frozenset()) -> Resolution:
     """What a bare `name` denotes when called from `scope`."""
     home = resolving_scope(scope, name)
-    return Resolution("none") if home is None else _outcome(home.binders[name])
+    return Resolution("none") if home is None else _outcome(home.binders[name], _following)
+
+
+def _aliased(binder: Binder, origin: tuple[str, str, PyScope], following: frozenset[int]) -> Resolution:
+    """What the one assignment `name = <name or module.attr>` makes the name denote (#90).
+
+    A definition or an imported symbol stays what it is. `module.attr` is
+    "member": the attribute of an in-repo module, bound as the call
+    `module.attr()` is. Anything else, and a name that leads back to itself, is
+    a value as before.
+    """
+    how, text, scope = origin
+    if id(binder) in following:
+        return Resolution("value")
+    following = following | {id(binder)}
+    if how == "name":
+        found = resolve(scope, text, following)
+        return found if found.kind in ("def", "symbol", "member") else Resolution("value")
+    module_name, attr = text.split(".", 1)
+    root = resolve(scope, module_name, following)
+    if root.kind == "alias" and root.target:
+        return Resolution("member", qualname=attr, target=root.target)
+    return Resolution("value")
 
 
-def _outcome(binders: list[Binder]) -> Resolution:
+def _outcome(binders: list[Binder], following: frozenset[int] = frozenset()) -> Resolution:
     """§4.2's outcome table, for the binders of one name in its resolving scope."""
-    distinct: dict[tuple[str | None, ...], Binder] = {}
+    distinct: dict[tuple[str | int | None, ...], Binder] = {}
     for binder in binders:
         if binder.kind in ("def", "class"):
-            key: tuple[str | None, ...] = ("def", binder.qualname)
+            key: tuple[str | int | None, ...] = ("def", binder.qualname)
         elif binder.kind == "import":
             key = ("import", binder.import_kind, binder.target)
+        elif binder.origin is not None and binder.origin[0] in ("name", "attr"):
+            key = ("alias", binder.origin[0], binder.origin[1], id(binder.origin[2]))
         else:
             key = ("value",)
         distinct.setdefault(key, binder)
@@ -622,6 +667,8 @@ def _outcome(binders: list[Binder]) -> Resolution:
             return Resolution("def", qualname=binder.qualname, module_level=binder.module_level)
         if binder.kind == "import" and binder.import_kind is not None and binder.import_kind != "unknown":
             return Resolution(binder.import_kind, target=binder.target)
+        if binder.origin is not None and binder.origin[0] in ("name", "attr"):
+            return _aliased(binder, binder.origin, following)
         return Resolution("value")
     # Unresolved imports of one name (`try: import ujson as json` /
     # `except ImportError: import json`) leave the repo whichever one runs. So
@@ -643,6 +690,9 @@ def _origin_receiver(how: str, name: str, scope: PyScope) -> Receiver | None:
     """What a value of this origin is, with the name it calls resolved in `scope`."""
     if how == "literal":
         return _BUILTIN_RECEIVER
+    if how in ("name", "attr"):
+        # An alias (#90) is the thing it names, not what that thing returns.
+        return None
     found = resolve(scope, name)
     if found.kind == "none":
         # Bound nowhere in the file, so the name is the builtin's own -- unless

graphite/hookinstall.py

@@ -159,6 +159,23 @@ def install_hooks(root: Path, interpreter: Path) -> list[str]:
     return relocated
 
 
+def chain_slots(hdir: Path) -> dict[str, dict[str, str | bool]]:
+    """Where another tool's hook for each trigger goes, and whether one is there.
+
+    Each trampoline runs `<hook>.local` beside it first when that file exists,
+    so that is where another tool's hook for the same event belongs, in either
+    install order. The name is part of the hook contract (docs/compatibility.md);
+    `doctor --json` and `init` report it so another tool need not read it out of
+    the trampoline's shell (channel rounds 323, 324). It is named relative to
+    the hooks directory, which `core.hooksPath` may put outside the repository,
+    so the report carries no path. `present` is the trampoline's own `[ -f ]`.
+    """
+    return {
+        hook: {"file": f"{hook}{CHAINED_SUFFIX}", "present": (hdir / f"{hook}{CHAINED_SUFFIX}").is_file()}
+        for hook in TRIGGERS
+    }
+
+
 def uninstall_hooks(root: Path) -> list[str]:
     """Remove graphite's trampolines, restoring anything they chained.
 

graphite/init.py

@@ -397,6 +397,7 @@ def init_project(
             "path": str(hookinstall.hooks_dir(root)),
             "action": "installed",
             "relocated": relocated,
+            "chain_slots": hookinstall.chain_slots(hookinstall.hooks_dir(root)),
         }
     elif install_hooks:
         # Not a git repo (yet). `hookinstall.install_hooks` would still write

graphite/resolve.py

@@ -1,11 +1,12 @@
 """Source resolution helpers for Graphite extraction."""
 from __future__ import annotations
 
+import ast
 import hashlib
 import json
 import posixpath
 import tomllib
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from functools import lru_cache
 from pathlib import Path, PurePosixPath
 from typing import TYPE_CHECKING, Final, Iterable
@@ -31,6 +32,94 @@ def _rel_path_set_digest(rel_paths: frozenset[str]) -> str:
         digest.update(b"\0")
     return digest.hexdigest()
 
+#: How many re-exports one name is followed through. A real package chain is a
+#: hop or two; the bound only has to be finite beside the cycle guard.
+_MAX_REEXPORT_HOPS: Final = 8
+
+#: `(package __init__ path, name it binds) -> (module, leading dots, name there)`
+ReexportTable = dict[tuple[str, str], tuple[str, int, str]]
+
+
+def _module_level_bindings(body: list[ast.stmt]) -> dict[str, list[ast.stmt]]:
+    """Every statement that binds each name at module level, nested ones included.
+
+    A name bound under `if` or `try` counts as bound there, and so does a
+    name an `import` or `def` binds: the statement list is what lets the caller
+    tell a name bound exactly once, by one `from X import name`, from a name
+    the package binds some other way too.
+    """
+    bound: dict[str, list[ast.stmt]] = {}
+
+    def add(name: str, stmt: ast.stmt) -> None:
+        bound.setdefault(name, []).append(stmt)
+
+    def visit(stmts: list[ast.stmt]) -> None:
+        for stmt in stmts:
+            if isinstance(stmt, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+                add(stmt.name, stmt)
+            elif isinstance(stmt, ast.Import):
+                for alias in stmt.names:
+                    add((alias.asname or alias.name).split(".", 1)[0], stmt)
+            elif isinstance(stmt, ast.ImportFrom):
+                for alias in stmt.names:
+                    if alias.name != "*":
+                        add(alias.asname or alias.name, stmt)
+            else:
+                for node in ast.walk(stmt):
+                    if isinstance(node, ast.Name) and isinstance(node.ctx, (ast.Store, ast.Del)):
+                        add(node.id, stmt)
+                    elif isinstance(node, ast.ExceptHandler) and node.name:
+                        add(node.name, stmt)
+                    elif isinstance(node, ast.alias):
+                        add((node.asname or node.name).split(".", 1)[0], stmt)
+                    elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+                        add(node.name, stmt)
+
+    visit(body)
+    return bound
+
+
+def _package_reexports(rel_path: str, source: bytes) -> ReexportTable:
+    """The names one `__init__.py` binds only by a top-level `from X import name`.
+
+    A name the file binds any other way too (assigned, defined, imported a
+    second time, imported under a condition) is left out, and so is a file that
+    does not parse: `from pkg import name` then stays bound to the package, as
+    it was before re-exports were followed.
+    """
+    try:
+        tree = ast.parse(source)
+    except (SyntaxError, ValueError, RecursionError):
+        return {}
+    bound = _module_level_bindings(tree.body)
+    table: ReexportTable = {}
+    for stmt in tree.body:
+        if not isinstance(stmt, ast.ImportFrom) or not stmt.module:
+            # `from . import sub` binds a submodule, which has its own path.
+            continue
+        for alias in stmt.names:
+            local = alias.asname or alias.name
+            if alias.name == "*" or len(bound.get(local, ())) != 1:
+                continue
+            table[(rel_path, local)] = (stmt.module, stmt.level, alias.name)
+    return table
+
+
+def _python_reexports(entries: Iterable[FileEntry]) -> ReexportTable:
+    """The re-export table of every package `__init__.py` among the entries."""
+    table: ReexportTable = {}
+    for entry in entries:
+        rel_path = PurePosixPath(entry.rel_path).as_posix()
+        if PurePosixPath(rel_path).name != "__init__.py":
+            continue
+        try:
+            source = Path(entry.abs_path).read_bytes()
+        except OSError:
+            continue
+        table.update(_package_reexports(rel_path, source))
+    return table
+
+
 _TS_EXTENSIONS = (".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs")
 _INDEX_NAMES = tuple(f"index{ext}" for ext in _TS_EXTENSIONS)
 _BUILTIN_OBJECTS = {
@@ -92,6 +181,14 @@ class SourceIndex:
     # (crate dir, declared idents) per manifest -- the authoritative answer to
     # "did THIS file's crate declare that dependency". See issue #38.
     cargo_crate_dependencies: tuple[tuple[str, frozenset[str]], ...] = ()
+    # What each package `__init__.py` re-exports by a plain `from X import name`
+    # (#87). Read from the files themselves, so extraction of an importer that
+    # did not change depends on it: see `python_reexport_digest`.
+    python_reexports: ReexportTable = field(default_factory=dict, compare=False, repr=False)
+    # rel path -> file node id, for the paths of the tree whose plain id another
+    # path has too (#82). Empty for a tree without such a pair. Set by
+    # `extract_all`, which owns how a file node id is made.
+    file_ids: dict[str, str] = field(default_factory=dict, compare=False, repr=False)
 
     @classmethod
     def from_entries(cls, entries: Iterable[FileEntry], cfg: Config | None = None) -> "SourceIndex":
@@ -116,8 +213,42 @@ class SourceIndex:
             cargo_crates=_load_cargo_crates(root, frozenset(rel_paths)),
             cargo_dependencies=_load_cargo_dependencies(root, frozenset(rel_paths)),
             cargo_crate_dependencies=_load_cargo_crate_dependencies(root, frozenset(rel_paths)),
+            python_reexports=_python_reexports(entries),
         )
 
+    def python_reexport_digest(self) -> str:
+        """Digest of the re-export table, for the cache key of a Python file.
+
+        An importer binds `from pkg import name` to whatever `pkg/__init__.py`
+        re-exports, and its bytes do not change when that does.
+        """
+        digest = hashlib.blake2b(digest_size=8)
+        for (rel_path, name), (module, level, original) in sorted(self.python_reexports.items()):
+            digest.update(f"{rel_path}\0{name}\0{level}\0{module}\0{original}\0".encode("utf-8", errors="replace"))
+        return digest.hexdigest()
+
+    def follow_python_reexport(self, rel_path: str, name: str) -> tuple[str, str]:
+        """The file and name that define `name` as `rel_path` exports it.
+
+        Follows `from X import name` statements the package `__init__.py`
+        makes, for as many steps as the source states. It stops where a hop does
+        not resolve to a file of the tree, where a name is bound some other way,
+        at a cycle, and at `_MAX_REEXPORT_HOPS`; each returns the last place
+        reached, which is `(rel_path, name)` itself when nothing is followed.
+        """
+        seen = {(rel_path, name)}
+        for _ in range(_MAX_REEXPORT_HOPS):
+            hop = self.python_reexports.get((rel_path, name))
+            if hop is None:
+                break
+            module, level, original = hop
+            target = self.resolve_python_module(rel_path, module, level)
+            if target is None or (target, original) in seen:
+                break
+            seen.add((target, original))
+            rel_path, name = target, original
+        return rel_path, name
+
     def file_set_digest(self) -> str:
         """Stable digest of the repo's file set.
 

{graphite_code-1.3.0.dist-info → graphite_code-1.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: graphite-code
-Version: 1.3.0
+Version: 1.4.0
 Summary: Local-first, zero-LLM knowledge graph extraction for codebases.
 Project-URL: Homepage, https://github.com/jared0565/graphite
 Project-URL: Repository, https://github.com/jared0565/graphite
@@ -48,7 +48,7 @@ Description-Content-Type: text/markdown
 
 Local-first, deterministic knowledge graph extraction for codebases — zero-LLM, daemon-maintained, agent-agnostic.
 
-**Status: 1.3.0, production/stable.** Published on PyPI as
+**Status: 1.4.0, production/stable.** Published on PyPI as
 [`graphite-code`](https://pypi.org/project/graphite-code/) with PEP 740
 attestations; supported on Windows, Linux and macOS with Python 3.11–3.14
 (every cell gates CI). What 1.x promises — CLI, JSON outputs, `graph.json`,

{graphite_code-1.3.0.dist-info → graphite_code-1.4.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
-graphite/__init__.py,sha256=sJRU6XXgmArJ1LdtGCTQ_XsPXmii2SK7NZwWLylO6Fo,2181
+graphite/__init__.py,sha256=GC0juqOmVzk_zpoOBLn2WPHFXWWoxCfPb4CvSCEqyCs,2181
 graphite/__main__.py,sha256=Bp5bcXE6M0AnuNW1LjOXOEvGG5r0fXZoeRb_k5Yxphs,149
 graphite/_cleanup_worker.py,sha256=oIXOPa1jHVP8ePRSwn27nZEHOAc4DSBrjeH2Ds9wuq8,19619
 graphite/_win32_ctypes.py,sha256=YLH4kpKjL7zUUOs9E8C-Kjdy45PJBd6eRUeKwiKdSV4,1476
 graphite/activation.py,sha256=Jcgk8AFvqbMNQiPAa2MTzSO0BAYRC5FX6MsZUjbDe1I,5249
-graphite/agent_hooks.py,sha256=pvnX224z8_742q8sOYUl0EL1855BoSR4Okd-xZj9gmE,61298
+graphite/agent_hooks.py,sha256=rIeA6ofRLDMSdf4MfFMUpnXHVcHHzht6NZpfgSOgZd4,64248
 graphite/agent_settings.py,sha256=Ec95ilPhkPOM3vW67pdsjYivnCyc5uCqWfCBu-DLI3A,11085
 graphite/analyze.py,sha256=BwiZ4lkQ8Oo8WvnIGLI03YSNUpynYvV46tVbzHH5iWQ,9304
 graphite/answer_contract.py,sha256=KTnGmtT6gvi28-PhLZp9vaj7FDvGrqLW_BvhAa-VPR4,31237
@@ -11,7 +11,7 @@ graphite/bootstrap.py,sha256=OPDzN9jSr8IE1N7xOnVKk3FgO2UqBTOUNcNV-pZAsus,8448
 graphite/buildlock.py,sha256=QXo4cnGGCmhxuuYdy6f5OHF82Yg6zHUMxLVdxwG49ic,5393
 graphite/cache.py,sha256=Mh28dYg9irXBvH-oa8jpFSM-ehXcs5FuNVHVzF_WRA8,9143
 graphite/channel.py,sha256=UNFAGuws6XFbkBu0fnVLepBDxT1BWAJlW33IPVlDi9M,72908
-graphite/cli.py,sha256=O0QjnQQ0Q5gZQwbxd96gUqj4GbcrVcPOI2b_twRPGNo,160778
+graphite/cli.py,sha256=JYypUmsaV3c3VILwI7ay0wd_D2m5PfAWStu55w0nMNg,161757
 graphite/cluster.py,sha256=j5dFT40DD7scD4h8d7XJoAGQIcJKpsKsrFceiJkOuzw,4066
 graphite/config.py,sha256=ZWhWOWYEyKGoHCp6vWI4M4NQM57ohf5BaX0Ty8HfWYM,9267
 graphite/context.py,sha256=vWMuFxqDGby-9Gs_t9XNJzKR-nZqwMdbU2y6N_GypWU,13215
@@ -21,7 +21,7 @@ graphite/daemon_launch.py,sha256=d6VhJVARdhBSdGWPHxKgveDisX5JWHlDJeV6tjLJWKw,232
 graphite/debt.py,sha256=mvxoFrICwbWP19YKlf1cZIPFg8qIf7Jgyr9kIweVBbE,4664
 graphite/dependency_install.py,sha256=hcwRmg74BfweXfRzzgRqHhLGEEIWokNLebJCxM2D80k,58600
 graphite/detach.py,sha256=BlUjeh_UcjpQ9DMRZFOgxhk83zUbMSTPmXe6t1FFEKE,1270
-graphite/doctor.py,sha256=SH5emKn0P78AU-6Us3atr4GvV1UZLZpo91W8OBkpJlM,34686
+graphite/doctor.py,sha256=4ZocGDXNFfAAeWempEjIe2-WwxROKygM04P3FfLC1qw,34733
 graphite/doctor_probes.py,sha256=pSU62zuHv3pxcXZWquUUvd6UVur-grfrr3CJ0PM8uis,89852
 graphite/engine_identity.py,sha256=hZYA9fBsg2fj_61Rtkc84XzJrdsa2MaDFOLZJV4I7eE,8951
 graphite/freshness.py,sha256=kkhs-ArInlv1XxedmQRAFiThvrHt11mN5UAGCQCU4A8,5284
@@ -30,11 +30,11 @@ graphite/graph.py,sha256=2mhbIrx4ekidgXnw3gLWDtGcVdvOmYfpZ4oATtwbao0,4284
 graphite/graph_io.py,sha256=rWjc3_Lq7DOg1_XuM4eY8GH9GwIHowo0CcABTIRtLyc,6563
 graphite/health.py,sha256=Sh8P6_RvEBaFeICUbhncqw5I-Nlge9ASTkQpxSUtKfs,5525
 graphite/hook_entry.py,sha256=0lfCZB9-B_9QBKagLhV_VIMVFcrOeAwpLcFXUjhMMpg,2655
-graphite/hookinstall.py,sha256=1fCjMeQsKVfOmrJm42p94SKL14hZ31R-WANZPZzkzmM,9344
+graphite/hookinstall.py,sha256=7qfboCBjP7DAeugbXXjZDDg-0aP7GJc_WhqxgJsOlV4,10215
 graphite/hookshim.py,sha256=4to9xkNOWPjbk1Es97KTTknjJM9gdHkbEDjCQq8ntec,3771
 graphite/incident_ledger.py,sha256=wHW-P_PJNollM_L9bAXHaxFeLb89wMXs7XX0VrH7aSw,8654
 graphite/ingest.py,sha256=0uzPN7fyokVOL622TTXd7COpd5CpViOrsRYDm53Q1Qw,11952
-graphite/init.py,sha256=TD7996Wp51-anUi1KjTyWyeMlXyR14BWnMDzK3uSZ0Y,41241
+graphite/init.py,sha256=yoCyQ83UJ7Nb_suq_HUAVOwPhHbqpWfKtfD4P3n_LPE,41322
 graphite/io.py,sha256=YBXfMcPsv1Lzun8ByW4BQlfgMm54akckLFrUhwWtleI,2996
 graphite/launchd_agent.py,sha256=rmKhhCbB-9FDU_3A1b2OlZxKpxZqdgtYnLbzkFMs_rI,4529
 graphite/listing.py,sha256=fxKBK7_1q9IcFK_VAhpQCKyDV7q_RajJ0r8O2h9rqes,1666
@@ -54,7 +54,7 @@ graphite/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 graphite/query.py,sha256=qOObUOJGtHTf_MWrxNM1ykfl7TR2aqZ7MBvjib4i01Y,29659
 graphite/query_plan.py,sha256=TLGwOnsL6Ia1hCsDzmWWBwtcn37Dn6aOuAvGowtgSXg,3768
 graphite/replacement_audit.py,sha256=AR97eZ0h8Rx5VWOW2rJSqDGwEVwEDj08kcSiepyidaE,12393
-graphite/resolve.py,sha256=-73GujPNFx12DKUTPknq3OpRaOkWe-dLbt-RrlZelCI,28710
+graphite/resolve.py,sha256=FMaOCWbCGD7aEpN5WOmdLs5Y35nGdw_G8SUuHtxqjV0,34778
 graphite/review.py,sha256=Dd35aA8n5R1Osoop769uymdOFFZMB4BFexAKJD9bO7o,27810
 graphite/savings.py,sha256=W5FbXScpteMTwngVUtDqPct99tHY7W8s3XlT4hbPJCY,3175
 graphite/systemd_unit.py,sha256=oPfdHwFJpfW1RnQeIkyVnOYvDhSRjll57424whQYWg4,4503
@@ -71,8 +71,8 @@ graphite/export/html.py,sha256=WB-9p0fpjFh-bTpHl5aYg1UdM_PGXwaZEtyR3lleNZU,8949
 graphite/export/json.py,sha256=oUrR1aXE5eiRDrj1_oXIl6qOPsTiqP3rmGtLfHF_nJc,1267
 graphite/export/md.py,sha256=JqxULAZHdsxBsbgeZVzZ08C0_ZmQ9Tsln_dAmvHmbjY,2557
 graphite/extract/__init__.py,sha256=HsF3yU1VcT3EsvUfxMJ0iVW2Ud_XrivnBGmdi9QTK3M,118
-graphite/extract/ast.py,sha256=uJi7RyZOZJtKmHZaNk98qqoJ_irke7rUXcipHslfjrc,139062
-graphite/extract/pyscope.py,sha256=QnyuKq4hnF4BIxAnxTYZ2aDgx-BtnzCnGYwWBcwNmbs,33878
+graphite/extract/ast.py,sha256=l5M6m768RtxWBj8eHMMLY8sLV4ChABAWZbybGRtHOIA,144260
+graphite/extract/pyscope.py,sha256=bLsH5vJI10nLM12lGEeyvI3uG5uKXX0Jq4wl5TjfJc4,36460
 graphite/routing/__init__.py,sha256=QlzeC4TbkzJNPn6vVrMH36FmpHrH0ZoJzjK_ckF-Z54,177
 graphite/routing/approval.py,sha256=9roEO0d5hBhg3VgUaN8cw4wxzgJn6oKzhO7eQQ9cShQ,13872
 graphite/routing/classifier.py,sha256=9JcVhxWnt9K_xMJkS-xiLUKYHi3LZiTGefkqBUSvvKc,6836
@@ -113,8 +113,8 @@ graphite/routing/zai_edit.py,sha256=Kra2tI9GkntQAhV1vNHlFlp4sY-ksq2-bY4N9fEfLEc,
 graphite/routing/zai_executor.py,sha256=cHUl7DbWRUhYg9Lwm3OiP6H3dI70y_b8iAWCyfgOPi0,6636
 graphite/routing/zai_probe.py,sha256=HL2vM8s2J4-n8Bp3l7QLpWLEk-PhZrt_rLc2cY65hvU,4771
 graphite/ts_resolver.mjs,sha256=wiKDWkJIC9__3wL49ty4W8hRc5biisNNtFhH1aFA47A,10822
-graphite_code-1.3.0.dist-info/METADATA,sha256=RGAU6kW0kTmOVDAnYHGJmsR2vLKXztPYF_KlvL8DaSI,48476
-graphite_code-1.3.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-graphite_code-1.3.0.dist-info/entry_points.txt,sha256=-BpYAYFyn58DYi-hrFW9hMz6mTwNsYI44s9gaef4MiM,87
-graphite_code-1.3.0.dist-info/licenses/LICENSE,sha256=mfotJ1Lk0VVUgoEPOIR7-x5cvYiz2UkuVH7e3fhoDiY,1066
-graphite_code-1.3.0.dist-info/RECORD,,
+graphite_code-1.4.0.dist-info/METADATA,sha256=5UbiMIRD_tve4MYmsHClCpKWc7IfospT5PDnSsxTu7Q,48476
+graphite_code-1.4.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+graphite_code-1.4.0.dist-info/entry_points.txt,sha256=-BpYAYFyn58DYi-hrFW9hMz6mTwNsYI44s9gaef4MiM,87
+graphite_code-1.4.0.dist-info/licenses/LICENSE,sha256=mfotJ1Lk0VVUgoEPOIR7-x5cvYiz2UkuVH7e3fhoDiY,1066
+graphite_code-1.4.0.dist-info/RECORD,,