node-walk 0.3.1__tar.gz → 0.4.0__tar.gz

{node_walk-0.3.1 → node_walk-0.4.0}/CHANGELOG.md

@@ -11,6 +11,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [0.4.0] - 2026-08-26
+
+---
+
 ## [0.3.1] - 2026-08-25
 
 ---

{node_walk-0.3.1 → node_walk-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: node-walk
-Version: 0.3.1
+Version: 0.4.0
 Summary: Semantic code intelligence — local-first graph of your codebase for humans and LLMs
 Author: CodeGraph Contributors
 License: MIT

node_walk-0.4.0/plans/receiver-resolution-plan.md

@@ -0,0 +1,361 @@
+# Receiver and Dependency-Injection Resolution Plan
+
+## Problem
+
+`CALLS` resolution is now able to use simple bindings, but it still assumes
+that the receiver's type can be found in one local fact. Real Python code often
+passes an implementation through several symbols before a call is made:
+
+```python
+class Controller:
+    def __init__(self, service: UserService):
+        self.service = service
+
+    def get(self, user_id):
+        return self.service.get_by_id(user_id)
+
+class App:
+    def __init__(self, controller: Controller):
+        self.controller = controller
+
+    def run(self, user_id):
+        return self.controller.get(user_id)
+```
+
+The resolver must answer one general question:
+
+> What symbol does this receiver expression denote at this call site, and
+> which member belongs to that symbol?
+
+This applies equally to local variables, constructor parameters, instance
+attributes, imported aliases, factories, and nested paths. It should not grow
+as a collection of DI, repository, or adapter special cases.
+
+## Goals
+
+- Resolve `receiver.member(...)` as `receiver binding -> member lookup`.
+- Support bindings that flow through multiple classes and methods.
+- Preserve source facts and explain every resolution decision.
+- Prefer a correct `PROBABLE` or `UNRESOLVED` result over an incorrect edge.
+- Keep resolution bounded and deterministic for dynamic Python.
+- Make re-resolution possible without reparsing source files.
+
+## Non-goals
+
+- Full Python type inference or runtime execution.
+- Proving arbitrary dynamic attribute assignment, monkey patching, or
+  metaclass behavior.
+- Modeling every possible container/service-locator framework in the first
+  implementation.
+
+## Current Gaps
+
+1. Binding facts currently store a type hint, but the resolver treats them as
+   isolated facts rather than a graph of aliases and assignments.
+2. `self.repository` may be established in `__init__` and used in another
+   method, so method-local lookup is insufficient.
+3. A binding such as `self.service = factory()` has no stable target unless the
+   factory return type or returned symbol is known.
+4. Nested receivers such as `self.repo.session.client.send()` require repeated
+   member resolution, not one string concatenation.
+5. Resolver order currently affects whether a binding is available when calls
+   are resolved.
+6. The visitor can emit duplicate or incomplete binding facts while walking
+   nested assignment nodes.
+7. FastAPI dependency declarations such as
+   `service: UserService = Depends(get_service)` mix a parameter annotation,
+   a provider reference, and framework metadata in one AST expression. Treating
+   the whole expression as an ordinary call loses the injected type contract.
+
+## Target Model
+
+Represent receiver resolution as a chain of typed steps:
+
+```text
+call site: self.repo.session.find
+  self.repo       -> Repository
+  Repository.session -> Session
+  Session.find    -> method symbol
+```
+
+Each step should carry:
+
+- expression/path (`self.repo`)
+- source scope and class owner
+- candidate symbol id(s)
+- evidence (`parameter_annotation`, `constructor_call`, `attribute_assignment`,
+  `import_alias`, `return_annotation`, `fastapi_depends`, etc.)
+- confidence (`RESOLVED`, `PROBABLE`, `UNRESOLVED`)
+- diagnostic details
+
+The existing `RelationshipFact` table remains the persisted observation layer.
+The implementation may add metadata fields or a dedicated binding index, but
+must not hide inferred bindings only in Python process state.
+
+## Resolution Pipeline
+
+### Phase 1: Normalize Extraction Facts
+
+Make the visitor emit stable facts without deciding the final target:
+
+- calls: `receiver_text`, `callee_name`, complete `raw_text`, call scope
+- assignments: target path and RHS expression
+- parameters: parameter path and annotation expression
+- returns: return expression and optional annotation
+- imports: local alias and imported qualified path
+
+Normalize target paths structurally where possible. For example, represent
+`self.repository` as path segments `self`, `repository`, while retaining the
+original text for diagnostics.
+
+Add tests for:
+
+- `service.get_by_id()`
+- `self.repository.get_by_id()`
+- `self.repo.session.client.send()`
+- alias assignments (`repo = self.repository`)
+- tuple/destructured assignments where safely supported
+- duplicate traversal not producing duplicate binding facts
+
+### Phase 2: Build a Repository Binding Index
+
+After all files are stored and imports/classes are known, build an index from
+binding facts. The index should support:
+
+- lookup by file and scope
+- lookup by enclosing class
+- lookup by exact path (`self.repository`)
+- lookup by root alias (`repository`)
+- lookup of the latest or applicable assignment before a call line
+
+Do not rely on fact insertion order. Use source line and lexical ownership to
+make the result deterministic.
+
+Initial binding sources, in priority order:
+
+1. explicit type annotation (`service: UserService`)
+2. constructor call (`service = UserService()`)
+3. imported symbol or module alias
+4. assignment from an already-known binding (`self.repo = repository`)
+5. annotated return value of a known factory
+6. FastAPI dependency parameter annotation or provider return annotation
+7. unique global fallback, marked `PROBABLE`
+
+### FastAPI `Depends()`
+
+Handle FastAPI dependency injection as a framework-specific binding pattern,
+not as a special case in member lookup. The common forms are:
+
+```python
+from fastapi import Depends
+
+def get_service() -> UserService:
+   return UserService()
+
+@router.get("/users/{user_id}")
+def get_user(
+   user_id: int,
+   service: UserService = Depends(get_service),
+):
+   return service.get_by_id(user_id)
+```
+
+Extraction should record separate facts:
+
+- parameter binding: `service -> UserService`
+- provider relationship: `get_user depends_on get_service`
+- optional provider return contract: `get_service -> UserService`
+
+The `Depends` wrapper itself should not become a misleading `CALLS` edge from
+the route handler to `Depends`. Instead:
+
+1. recognize a default value whose call target is `Depends`
+2. extract its first argument as the provider symbol/path
+3. preserve the parameter annotation as the strongest receiver type evidence
+4. resolve `service.get_by_id()` through `UserService`
+5. optionally materialize a separate `DEPENDS_ON` relationship type later;
+   until then, retain the provider fact for diagnostics without polluting
+   runtime call traversal
+
+Support both named and module-qualified wrappers:
+
+- `Depends(get_service)`
+- `fastapi.Depends(get_service)`
+- imported aliases where the import resolver proves the alias refers to
+  `fastapi.Depends`
+
+Do not assume every function passed to `Depends` returns the annotated type.
+When both exist, compare the provider return annotation and parameter
+annotation. If they disagree, keep the parameter binding `PROBABLE` and record
+the conflict rather than creating a resolved edge silently.
+
+### Phase 3: Resolve Binding Chains
+
+Introduce a resolver/service with an API equivalent to:
+
+```python
+resolve_receiver(call_fact) -> ReceiverResolution
+resolve_member(receiver_resolution, member_name) -> SymbolResolution
+```
+
+For each receiver path:
+
+1. Resolve the root (`self`, local name, imported alias, or known symbol).
+2. Apply each remaining attribute segment through class/module member lookup.
+3. Stop on ambiguity, missing member, or unsupported dynamic behavior.
+4. Detect cycles and enforce a small maximum path depth.
+
+`self` resolves to the enclosing class instance. A binding created in
+`__init__` is available to other methods of the same class, but not to an
+unrelated class merely because the attribute names match.
+
+### Phase 4: Propagate Constructor and Method Contracts
+
+Support the common multi-class DI flow without pretending to execute Python:
+
+```python
+class Controller:
+    def __init__(self, service: UserService):
+        self.service = service
+```
+
+Record that `Controller.service` has type `UserService`. Then:
+
+- resolve `Controller.service.get_by_id` in any controller method
+- resolve `Controller(...)` constructor calls to the class and initializer
+- pass known argument bindings into typed parameters when a call target is
+  known
+
+For a call such as `Controller(service)`, bind the constructor parameter
+`service` to the argument's known symbol. For unknown arguments, retain the
+annotation as a probable contract rather than inventing a target.
+
+Handle return annotations next. A known `make_service() -> UserService`
+should allow `make_service().get_by_id()` only when the AST shape and symbol
+model make that relationship unambiguous.
+
+### Phase 5: Materialize Calls with Evidence
+
+Update `CrossFileCallResolver` to consume the binding index and receiver
+resolver. Its decision order should be:
+
+1. same-class member resolution for `self` / `cls`
+2. exact receiver-path binding and member lookup
+3. imported module/class alias lookup
+4. direct imported function lookup
+5. narrowly scoped unique fallback
+6. unresolved result with diagnostics
+
+Diagnostics should include:
+
+- receiver expression
+- resolved binding path and target
+- member lookup path
+- evidence used
+- ambiguity or missing-member reason
+- resolution confidence
+
+Remove the old one-off class-name receiver heuristic once equivalent coverage
+exists. Keep arrow direction and final graph materialization unchanged.
+
+## Multiple-Class Scenarios to Cover
+
+These should become fixtures and integration tests:
+
+1. **Constructor injection**
+   `Controller.__init__(service: Service)` followed by
+   `self.service.method()`.
+2. **Injection across an application root**
+   `App(controller: Controller)` followed by `self.controller.get()`.
+3. **Local aliasing**
+   `repository = self.repository` followed by `repository.find()`.
+4. **Factory return**
+   `make_repository() -> Repository` followed by
+   `make_repository().find()` where the AST supports a safe representation.
+5. **Imported implementation**
+   `from package.repo import Repository` followed by typed injection.
+6. **FastAPI typed dependency**
+   `service: UserService = Depends(get_service)` followed by
+   `service.get_by_id()`. The graph should resolve the method call to
+   `UserService.get_by_id` and retain the provider fact separately.
+7. **FastAPI untyped dependency**
+   `service = Depends(get_service)`. Resolve through the provider return
+   annotation only when it is unambiguous; otherwise mark the binding
+   `PROBABLE` or `UNRESOLVED` with a diagnostic.
+8. **FastAPI qualified dependency**
+   `service: UserService = fastapi.Depends(get_service)`.
+9. **Module receiver**
+   `package.service.create()` resolved through the imported module symbol.
+10. **Nested attributes**
+    `self.repository.session.execute()` with each intermediate member known.
+11. **Ambiguous implementations**
+    Two classes share a member name; result must not become a false resolved
+    edge without binding evidence.
+12. **Inheritance**
+    A method is declared on a base class and called through an injected
+    subclass; member lookup may walk known base classes.
+13. **Unsupported dynamic code**
+    `setattr(self, name, value)` remains unresolved with a useful diagnostic.
+
+## Testing Strategy
+
+### Unit tests
+
+- path parsing and normalization
+- binding index precedence
+- lexical/class ownership lookup
+- member lookup across one and multiple segments
+- cycle and depth-limit behavior
+- FastAPI `Depends` extraction without a false `CALLS` edge to `Depends`
+- provider/parameter annotation agreement and conflict diagnostics
+- confidence and diagnostic payloads
+
+### Integration tests
+
+Index temporary multi-file projects and assert the final `CALLS` edge target.
+For every fixture also inspect the original call fact and assert its resolver
+diagnostics, so a passing edge cannot conceal an accidental fallback.
+
+### Regression matrix
+
+Run the existing analyzer, resolution, indexer, query, storage, and web tests.
+Add explicit assertions that unresolved or ambiguous calls do not create a
+resolved relationship to a same-named method in an unrelated class.
+
+## Migration Order
+
+1. Add normalized binding/call fact fields without changing graph output.
+2. Add binding-index data structures and unit tests.
+3. Add receiver-chain and member lookup service.
+4. Route `CrossFileCallResolver` through that service.
+5. Add constructor argument propagation and class attribute contracts.
+6. Add FastAPI `Depends` extraction and provider contracts.
+7. Add return annotations and bounded factory support.
+8. Remove obsolete resolver heuristics and duplicate extraction paths.
+9. Re-index representative repositories and compare resolved/probable/
+   unresolved counts before and after.
+
+## Acceptance Criteria
+
+- `self.repository.get_by_id()` resolves to the repository method.
+- The same repository binding works from any method of its owning class.
+- A controller injected into another class resolves through the second class.
+- A FastAPI parameter using `Depends(provider)` resolves calls through its
+  annotation or unambiguous provider return type, without a false call to
+  `Depends`.
+- Nested known receiver paths resolve segment by segment.
+- Ambiguous and dynamic cases remain non-resolved and explain why.
+- Existing 80-test baseline remains green, with new multi-class fixtures green.
+- Re-running resolution produces the same results independent of file traversal
+  order.
+
+## Risks and Guardrails
+
+- **False positives:** require binding evidence before marking a call resolved.
+- **Stale assignments:** use source location and lexical scope when selecting
+  an applicable binding.
+- **Dynamic Python:** cap path depth and return unresolved diagnostics.
+- **Performance:** build indexes once per indexing pass, not with full-repository
+  scans for every call fact.
+- **Migration churn:** keep the existing graph edge contract while replacing
+  only the resolution internals.

{node_walk-0.3.1 → node_walk-0.4.0}/src/node_walk/analysis/python/visitor.py

@@ -712,18 +712,42 @@ class SymbolCollector:
             return bindings
 
         for child in params_node.children:
-            if child.type not in {"typed_parameter", "typed_default_parameter"}:
+            if child.type not in {"typed_parameter", "typed_default_parameter", "default_parameter"}:
                 continue
 
             identifier = next((c for c in child.children if c.type == "identifier"), None)
             type_node = next((c for c in child.children if c.type == "type"), None)
-            if not identifier or not type_node:
+            
+            if not identifier:
                 continue
 
             param_name = node_text(identifier, self.source)
-            type_name = node_text(type_node, self.source)
-            if param_name and type_name:
-                bindings[param_name] = type_name
+            type_name = node_text(type_node, self.source) if type_node else ""
+            provider_ref = ""
+
+            # Check for FastAPI Depends in default value
+            if child.type in {"typed_default_parameter", "default_parameter"}:
+                # The default value is usually after the '=' sign
+                eq_found = False
+                for c in child.children:
+                    if c.type == "=":
+                        eq_found = True
+                        continue
+                    if eq_found and c.type == "call":
+                        func_node = c.child_by_field_name("function")
+                        if func_node:
+                            call_name = node_text(func_node, self.source)
+                            if call_name in {"Depends", "fastapi.Depends"}:
+                                args_node = c.child_by_field_name("arguments")
+                                if args_node:
+                                    for arg in args_node.children:
+                                        if arg.type in {"identifier", "attribute"}:
+                                            provider_ref = node_text(arg, self.source)
+                                            break
+
+            if param_name and (type_name or provider_ref):
+                # If we have both, prefer type_name for the binding, but we can store provider_ref in metadata
+                bindings[param_name] = type_name or provider_ref
                 self.relationship_facts.append(
                     RelationshipFact(
                         file_id=self.file_info.id,
@@ -733,7 +757,12 @@ class SymbolCollector:
                         simple_name=param_name.split(".")[-1],
                         qualified_hint=type_name,
                         source_location=SourceLocation(file_id=self.file_info.id, line=start_line(child)),
-                        metadata={"binding_type": "parameter"},
+                        scope_symbol_id=func_sym.id,
+                        metadata={
+                            "binding_type": "parameter",
+                            "provider_ref": provider_ref,
+                            "fastapi_depends": bool(provider_ref)
+                        },
                     )
                 )
 
@@ -761,11 +790,11 @@ class SymbolCollector:
         if not target_expr:
             return
 
-        inferred_hint = self._infer_assignment_binding_hint(node, bindings)
-        if not inferred_hint:
+        inferred_hint, provider_ref = self._infer_assignment_binding_hint(node, bindings)
+        if not inferred_hint and not provider_ref:
             return
 
-        bindings[target_expr] = inferred_hint
+        bindings[target_expr] = inferred_hint or provider_ref
         self.relationship_facts.append(
             RelationshipFact(
                 file_id=self.file_info.id,
@@ -776,7 +805,12 @@ class SymbolCollector:
                 receiver_text=".".join(target_expr.split(".")[:-1]),
                 qualified_hint=inferred_hint,
                 source_location=SourceLocation(file_id=self.file_info.id, line=start_line(node)),
-                metadata={"binding_type": "assignment"},
+                scope_symbol_id=func_sym.id,
+                metadata={
+                    "binding_type": "assignment",
+                    "provider_ref": provider_ref,
+                    "fastapi_depends": bool(provider_ref)
+                },
             )
         )
 
@@ -795,7 +829,7 @@ class SymbolCollector:
                     return text
         return ""
 
-    def _infer_assignment_binding_hint(self, node: Node, bindings: dict[str, str]) -> str:
+    def _infer_assignment_binding_hint(self, node: Node, bindings: dict[str, str]) -> tuple[str, str]:
         rhs_started = False
         rhs_identifier = ""
         for child in node.children:
@@ -803,12 +837,19 @@ class SymbolCollector:
                 if child.type == "call":
                     func_node = child.child_by_field_name("function")
                     if func_node:
-                        return node_text(func_node, self.source)
+                        call_name = node_text(func_node, self.source)
+                        if call_name in {"Depends", "fastapi.Depends"}:
+                            args_node = child.child_by_field_name("arguments")
+                            if args_node:
+                                for arg in args_node.children:
+                                    if arg.type in {"identifier", "attribute"}:
+                                        return "", node_text(arg, self.source)
+                        return call_name, ""
                 if child.type in {"identifier", "attribute"} and not rhs_identifier:
                     rhs_identifier = node_text(child, self.source).strip()
             elif child.type == "=":
                 rhs_started = True
 
         if rhs_identifier:
-            return bindings.get(rhs_identifier, "")
-        return ""
+            return bindings.get(rhs_identifier, ""), ""
+        return "", ""

{node_walk-0.3.1 → node_walk-0.4.0}/src/node_walk/resolution/calls.py

@@ -219,85 +219,52 @@ class CrossFileCallResolver(FactResolver):
     def name(self) -> str:
         return "CrossFileCallResolver"
 
+    def run(self, store: GraphStore, facts: list[RelationshipFact]) -> int:
+        from node_walk.resolution.receiver import BindingIndex, ReceiverService
+        self._index = BindingIndex(store)
+        self._service = ReceiverService(store, self._index)
+        return super().run(store, facts)
+
     def resolve(self, store: GraphStore, fact: RelationshipFact) -> ResolutionResult | None:
         if fact.fact_type != FactType.CALL:
             return None
 
-        # 1. Fetch resolved imports and bindings for this call's file/scope.
+        # 1. Try resolving through receiver chains
+        if fact.receiver_text:
+            receiver_res = self._service.resolve_receiver(fact)
+            if receiver_res:
+                member_res = self._service.resolve_member(receiver_res, fact.simple_name)
+                if member_res:
+                    return ResolutionResult(
+                        status=FactStatus(member_res.confidence.lower()),
+                        resolved_target_id=member_res.resolved_symbol_id,
+                        diagnostics={
+                            "strategy": "cross_file_receiver_chain",
+                            "receiver_diagnostics": receiver_res.diagnostics,
+                            "member_diagnostics": member_res.diagnostics,
+                            "evidence": receiver_res.evidence
+                        }
+                    )
+                else:
+                    return ResolutionResult(
+                        status=FactStatus.UNRESOLVED,
+                        diagnostics={
+                            "strategy": "cross_file_missing_member",
+                            "receiver_diagnostics": receiver_res.diagnostics
+                        }
+                    )
+
+        # 2. Try simple import match for direct function calls
         import_facts = store.get_relationship_facts(
             fact_type=FactType.IMPORT, status=FactStatus.RESOLVED
         )
-        file_imports = [f for f in import_facts if f.file_id == fact.file_id]
-        binding_facts = store.get_relationship_facts(
-            fact_type=FactType.BINDING, status=FactStatus.RESOLVED
-        )
-        caller = store.get_symbol(fact.source_symbol_id)
-        enclosing_class_id = ""
-        current_id = caller.parent_id if caller else ""
-        while current_id:
-            current = store.get_symbol(current_id)
-            if not current:
-                break
-            if current.kind in (SymbolKind.CLASS, SymbolKind.INTERFACE):
-                enclosing_class_id = current.id
-                break
-            current_id = current.parent_id or ""
-
-        binding_source_ids = {fact.source_symbol_id}
-        if enclosing_class_id:
-            for candidate in store.get_all_symbols():
-                current_id = candidate.parent_id
-                while current_id:
-                    current = store.get_symbol(current_id)
-                    if not current:
-                        break
-                    if current.id == enclosing_class_id:
-                        binding_source_ids.add(candidate.id)
-                        break
-                    current_id = current.parent_id or ""
-        scope_bindings = [
-            f for f in binding_facts
-            if f.file_id == fact.file_id
-            and f.source_symbol_id in binding_source_ids
-            and f.resolved_target_id
-        ]
-
-        # 2. Build local namespace maps from imports and receiver bindings.
-        import_map: dict[str, str] = {}
-        for imp in file_imports:
-            # simple_name of the import fact is the imported name
-            # e.g., `from jarvis.model import adapter` -> simple_name = `adapter`
-            # For now we map the simple_name to the resolved target ID
-            if imp.resolved_target_id:
-                import_map[imp.simple_name] = imp.resolved_target_id
-
-        binding_map = {
-            binding.raw_text: binding.resolved_target_id for binding in scope_bindings}
-
-        # 3. Resolve the receiver, then resolve its member.
-        match_id = None
-        receiver_id = binding_map.get(fact.receiver_text, "")
-        if not receiver_id:
-            receiver_id = import_map.get(fact.receiver_text, "")
-
-        if receiver_id:
-            receiver_sym = store.get_symbol(receiver_id)
-            if receiver_sym:
-                target_qname = f"{receiver_sym.qualified_name}.{fact.simple_name}"
-                candidates = store.find_symbols_by_qualified_name(target_qname)
-                if candidates:
-                    match_id = candidates[0].id
-
-        # Case B: `chat()` where `chat` is imported directly.
-        elif not fact.receiver_text and fact.simple_name in import_map:
-            match_id = import_map[fact.simple_name]
-
-        if match_id:
-            return ResolutionResult(
-                status=FactStatus.RESOLVED,
-                resolved_target_id=match_id,
-                diagnostics={"strategy": "cross_file_import_aware"}
-            )
+        for imp in import_facts:
+            if imp.file_id == fact.file_id and imp.simple_name == fact.simple_name and imp.resolved_target_id:
+                return ResolutionResult(
+                    status=FactStatus.RESOLVED,
+                    resolved_target_id=imp.resolved_target_id,
+                    diagnostics={"strategy": "cross_file_direct_import"}
+                )
 
         # 4. Fallback: Unambiguous global match
         # If we couldn't resolve via imports, maybe the simple name is completely unique across the repo?

node_walk-0.4.0/src/node_walk/resolution/receiver.py

@@ -0,0 +1,198 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from node_walk.ir.enums import FactStatus, FactType, SymbolKind
+from node_walk.ir.models import RelationshipFact, Symbol
+from node_walk.storage.base import GraphStore
+
+
+@dataclass
+class ReceiverResolution:
+    resolved_symbol_id: str
+    confidence: str  # "RESOLVED", "PROBABLE", "UNRESOLVED"
+    diagnostics: dict
+    evidence: str
+
+
+@dataclass
+class SymbolResolution:
+    resolved_symbol_id: str
+    confidence: str
+    diagnostics: dict
+
+
+class BindingIndex:
+    """
+    Indexes resolved BINDING facts for fast lookup by file, scope, and path.
+    """
+
+    def __init__(self, store: GraphStore):
+        self._store = store
+        self._bindings_by_file: dict[str, list[RelationshipFact]] = {}
+        
+        # Load all resolved bindings
+        for fact in self._store.get_relationship_facts(fact_type=FactType.BINDING):
+            if fact.status in (FactStatus.RESOLVED, FactStatus.PROBABLE) and fact.resolved_target_id:
+                self._bindings_by_file.setdefault(fact.file_id, []).append(fact)
+
+    def get_binding(self, file_id: str, scope_id: str, path: str) -> RelationshipFact | None:
+        """
+        Look up the most applicable binding for a path in the given scope.
+        """
+        bindings = self._bindings_by_file.get(file_id, [])
+        if not bindings:
+            return None
+
+        # Gather acceptable scope IDs (current scope + enclosing class)
+        valid_scope_ids = {scope_id}
+        
+        caller = self._store.get_symbol(scope_id)
+        if caller:
+            current_id = caller.parent_id
+            while current_id:
+                current = self._store.get_symbol(current_id)
+                if not current:
+                    break
+                if current.kind in (SymbolKind.CLASS, SymbolKind.INTERFACE):
+                    valid_scope_ids.add(current.id)
+                    # Also include constructor method as a valid scope for class attributes
+                    for m_id in self._get_init_methods(current.id):
+                        valid_scope_ids.add(m_id)
+                    break
+                current_id = current.parent_id
+
+        # Find exact path matches in valid scopes
+        applicable = [
+            b for b in bindings 
+            if b.raw_text == path and b.scope_symbol_id in valid_scope_ids
+        ]
+        
+        if applicable:
+            # Sort by line number to get the latest assignment before usage, or just the first for now.
+            return applicable[-1]
+
+        return None
+
+    def _get_init_methods(self, class_id: str) -> list[str]:
+        # Return the IDs of any __init__ methods in the class
+        inits = []
+        cls_sym = self._store.get_symbol(class_id)
+        if not cls_sym:
+            return inits
+        
+        init_qname = f"{cls_sym.qualified_name}.__init__"
+        for s in self._store.find_symbols_by_qualified_name(init_qname):
+            inits.append(s.id)
+        return inits
+
+
+class ReceiverService:
+    def __init__(self, store: GraphStore, index: BindingIndex):
+        self._store = store
+        self._index = index
+
+    def resolve_receiver(self, call_fact: RelationshipFact) -> ReceiverResolution | None:
+        receiver_text = call_fact.receiver_text
+        if not receiver_text:
+            return None
+            
+        # Support nested paths (self.repo.session)
+        segments = receiver_text.split(".")
+        
+        # 0. Check exact path in BindingIndex (e.g., self.repository, self.repo.session)
+        exact_binding = self._index.get_binding(call_fact.file_id, call_fact.scope_symbol_id, receiver_text)
+        if exact_binding:
+            confidence = "RESOLVED" if exact_binding.status == FactStatus.RESOLVED else "PROBABLE"
+            return ReceiverResolution(
+                resolved_symbol_id=exact_binding.resolved_target_id,
+                confidence=confidence,
+                diagnostics={"strategy": "binding_index_exact", "binding_id": exact_binding.id},
+                evidence=exact_binding.metadata.get("binding_type", "unknown")
+            )
+
+        # 1. Resolve root segment
+        root_segment = segments[0]
+        current_resolved_id = None
+        confidence = "RESOLVED"
+        diagnostics = {}
+        evidence = ""
+        
+        # Check if root is 'self'
+        if root_segment == "self":
+            caller = self._store.get_symbol(call_fact.scope_symbol_id)
+            if caller:
+                enclosing = self._get_enclosing_class(caller)
+                if enclosing:
+                    current_resolved_id = enclosing.id
+                    diagnostics={"strategy": "self"}
+                    evidence = "self"
+
+        # 1. Check BindingIndex
+        binding = self._index.get_binding(call_fact.file_id, call_fact.scope_symbol_id, root_segment)
+        print(f"DEBUG: resolve_receiver path='{receiver_text}', root='{root_segment}', caller_id={call_fact.scope_symbol_id}, binding={binding}")
+        if not current_resolved_id and binding:
+                confidence = "RESOLVED" if binding.status == FactStatus.RESOLVED else "PROBABLE"
+                current_resolved_id = binding.resolved_target_id
+                diagnostics={"strategy": "binding_index", "binding_id": binding.id}
+                evidence=binding.metadata.get("binding_type", "unknown")
+
+        # Check imports for root
+        if not current_resolved_id:
+            import_facts = self._store.get_relationship_facts(
+                fact_type=FactType.IMPORT, status=FactStatus.RESOLVED
+            )
+            for imp in import_facts:
+                if imp.file_id == call_fact.file_id and imp.simple_name == root_segment and imp.resolved_target_id:
+                    current_resolved_id = imp.resolved_target_id
+                    confidence = "RESOLVED"
+                    diagnostics={"strategy": "import_alias"}
+                    evidence = "import"
+                    break
+
+        if not current_resolved_id:
+            return None
+
+        # 2. Apply remaining segments
+        for segment in segments[1:]:
+            res = self.resolve_member(
+                ReceiverResolution(current_resolved_id, confidence, diagnostics, evidence), 
+                segment
+            )
+            if not res:
+                return None
+            current_resolved_id = res.resolved_symbol_id
+            confidence = res.confidence
+
+        return ReceiverResolution(
+            resolved_symbol_id=current_resolved_id,
+            confidence=confidence,
+            diagnostics=diagnostics,
+            evidence=evidence
+        )
+
+    def resolve_member(self, receiver_res: ReceiverResolution, member_name: str) -> SymbolResolution | None:
+        receiver_sym = self._store.get_symbol(receiver_res.resolved_symbol_id)
+        if not receiver_sym:
+            return None
+
+        target_qname = f"{receiver_sym.qualified_name}.{member_name}"
+        candidates = self._store.find_symbols_by_qualified_name(target_qname)
+        if candidates:
+            return SymbolResolution(
+                resolved_symbol_id=candidates[0].id,
+                confidence=receiver_res.confidence,
+                diagnostics={"strategy": "member_lookup"}
+            )
+            
+        return None
+
+    def _get_enclosing_class(self, sym: Symbol) -> Symbol | None:
+        current_id = sym.parent_id
+        while current_id:
+            current = self._store.get_symbol(current_id)
+            if not current:
+                return None
+            if current.kind in (SymbolKind.CLASS, SymbolKind.INTERFACE):
+                return current
+            current_id = current.parent_id
+        return None

{node_walk-0.3.1 → node_walk-0.4.0}/tests/test_indexer.py

@@ -149,3 +149,42 @@ class TransactionService:
         assert any(rel.target_id == repository_method.id for rel in calls)
     finally:
         store.close()
+
+def test_indexer_resolves_fastapi_depends(tmp_path):
+    project = tmp_path / "fastapi_project"
+    project.mkdir()
+    (project / "main.py").write_text(
+        """
+class UserService:
+    def get_by_id(self, user_id):
+        return user_id
+
+def get_service() -> UserService:
+    return UserService()
+
+def get_user(service: UserService = Depends(get_service)):
+    return service.get_by_id(1)
+""".strip(),
+        encoding="utf-8",
+    )
+
+    db_path = tmp_path / "graph5.db"
+    store = SQLiteGraphStore(db_path)
+    try:
+        from node_walk.indexer import Indexer
+        Indexer(store).index(project)
+
+        get_user = next(
+            s for s in store.get_all_symbols()
+            if s.qualified_name == "main.get_user"
+        )
+        service_method = next(
+            s for s in store.get_all_symbols()
+            if s.qualified_name == "main.UserService.get_by_id"
+        )
+
+        calls = store.get_relationships_from(
+            get_user.id, RelationshipType.CALLS)
+        assert any(rel.target_id == service_method.id for rel in calls)
+    finally:
+        store.close()