interlinked-mapper 0.3.10__tar.gz → 0.3.11__tar.gz

{interlinked_mapper-0.3.10 → interlinked_mapper-0.3.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: interlinked-mapper
-Version: 0.3.10
+Version: 0.3.11
 Summary: A Python program topology explorer — visualize the shape of your codebase
 License: MIT
 Project-URL: Homepage, https://github.com/austerecryptid/interlinked

{interlinked_mapper-0.3.10 → interlinked_mapper-0.3.11}/interlinked/analyzer/graph.py

@@ -15,6 +15,7 @@ from interlinked.models import (
 # Method names so common on builtins (dict, list, set, str, etc.) that resolving
 # them to project symbols by bare-name matching is almost always a false positive.
 # e.g. `op_dict.items()` should NOT resolve to `ActionCost.items`.
+# Checked against the LAST component of dotted targets (e.g. "effect.get" → "get").
 _BUILTIN_METHOD_NAMES: frozenset[str] = frozenset({
     # dict
     "items", "keys", "values", "get", "pop", "update", "setdefault",
@@ -28,8 +29,9 @@ _BUILTIN_METHOD_NAMES: frozenset[str] = frozenset({
     # str
     "strip", "split", "join", "replace", "startswith", "endswith",
     "lower", "upper", "format", "encode", "decode",
-    # general
+    # general / logging
     "close", "read", "write", "flush", "seek", "tell",
+    "warning", "error", "info", "debug", "exception", "critical",
 })
 
 
@@ -236,36 +238,48 @@ class CodeGraph:
                 source = next(iter(candidates))
 
         if target not in node_ids:
-            # Never resolve bare builtin method names — they match too
-            # broadly (e.g. "items" matching ActionCost.items when the
-            # actual call is dict.items()).
-            if target in _BUILTIN_METHOD_NAMES:
+            # Check the last dotted component against builtin method names.
+            # Catches both bare "items" and dotted "effect.get", "args.items".
+            leaf = target.rsplit(".", 1)[-1]
+            if leaf in _BUILTIN_METHOD_NAMES:
                 return edge
 
+            # Dotted targets like "effect.get" or "logger.warning" where the
+            # root is NOT a known node are local-variable method calls —
+            # resolving them through the name index produces false positives.
+            if "." in target:
+                root = target.split(".", 1)[0]
+                # If the root isn't itself a project node, it's a local var
+                if root not in node_ids and root not in name_index:
+                    return edge
+
             candidates = name_index.get(target, set())
             if len(candidates) == 1:
                 target = next(iter(candidates))
             elif len(candidates) > 1:
-                # For CALLS edges, a bare name like `process()` in Python
-                # NEVER resolves to the same class — you need `self.process()`
-                # for that.  Exclude the source itself to prevent self-call
-                # artifacts, and prefer module-level over class-level.
+                # Exclude self-calls (bare `process()` != `self.process()`)
                 filtered = candidates - {source}
                 if not filtered:
                     filtered = candidates
 
-                # Extract the top-level module from the source
+                # Prefer candidates sharing the longest common prefix with
+                # the source.  This ensures a call from engine.rules.resolver
+                # to _resolve_entity_ref picks resolver's own definition
+                # over engine.rules.field_paths._resolve_entity_ref.
                 src_parts = source.split(".")
-                src_module = src_parts[0] if src_parts else source
-
-                # Score candidates: prefer same module, then shorter paths
-                # (module-level functions are shorter than class methods)
-                best = None
-                for c in filtered:
-                    if c.startswith(src_module + "."):
-                        if best is None or c.count(".") < best.count("."):
-                            best = c
-                target = best or next(iter(filtered))
+
+                def _common_prefix_len(c: str) -> int:
+                    c_parts = c.split(".")
+                    n = 0
+                    for a, b in zip(src_parts, c_parts):
+                        if a == b:
+                            n += 1
+                        else:
+                            break
+                    return n
+
+                best = max(filtered, key=lambda c: (_common_prefix_len(c), -c.count(".")))
+                target = best
 
         if source == edge.source and target == edge.target:
             return edge

{interlinked_mapper-0.3.10 → interlinked_mapper-0.3.11}/interlinked/analyzer/parser.py

@@ -34,6 +34,7 @@ import warnings
 from pathlib import Path
 from typing import Any
 
+from interlinked.analyzer.graph import _BUILTIN_METHOD_NAMES
 from interlinked.models import NodeData, EdgeData, SymbolType, EdgeType
 
 # Python builtins we should never create nodes/edges for
@@ -323,7 +324,17 @@ def parse_project(root: str | Path) -> tuple[list[NodeData], list[EdgeData]]:
                     metadata=e.metadata,
                 ))
             else:
-                # Keep the raw call target — external library calls visible to auditors
+                # Keep the raw call target — external library calls visible
+                # to auditors.  BUT filter out localvar.builtin_method()
+                # patterns: if the inferencer couldn't resolve the target
+                # and the leaf is a common builtin method name, it's almost
+                # certainly a dict/list/str/logging method on a local var
+                # (e.g. effect.get(), args.items(), logger.warning()).
+                # Real project method calls resolve through the type system.
+                if "." in raw_target:
+                    leaf = raw_target.rsplit(".", 1)[-1]
+                    if leaf in _BUILTIN_METHOD_NAMES:
+                        continue
                 resolved_edges.append(e)
             continue
 

{interlinked_mapper-0.3.10 → interlinked_mapper-0.3.11}/interlinked_mapper.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: interlinked-mapper
-Version: 0.3.10
+Version: 0.3.11
 Summary: A Python program topology explorer — visualize the shape of your codebase
 License: MIT
 Project-URL: Homepage, https://github.com/austerecryptid/interlinked

{interlinked_mapper-0.3.10 → interlinked_mapper-0.3.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "interlinked-mapper"
-version = "0.3.10"
+version = "0.3.11"
 description = "A Python program topology explorer — visualize the shape of your codebase"
 readme = "README.md"
 license = {text = "MIT"}

{interlinked_mapper-0.3.10 → interlinked_mapper-0.3.11}/tests/test_accuracy.py

@@ -917,6 +917,91 @@ class TestParserSkipDirs:
 # ══════════════════════════════════════════════════════════════════════
 
 
+class TestFalsePositiveEdges:
+    """Regression tests for false positive edge resolution.
+
+    These patterns caused incorrect edges in production:
+    - effect.get(), args.items() — dotted builtin methods not caught
+    - logger.warning() — logging method resolving to project symbols
+    - _resolve_entity_ref — same-name function in sibling module
+    """
+
+    @pytest.fixture(autouse=True)
+    def setup(self):
+        self.graph, self.engine, _, _ = _build(FIXTURES)
+
+    def _edge_targets_from(self, source_partial: str, edge_type: EdgeType | None = None) -> set[str]:
+        """All edge targets from a source matching partial name."""
+        src = _find(self.graph, source_partial)
+        return {
+            e.target for e in self.graph.all_edges()
+            if e.source == src
+            and (edge_type is None or e.edge_type == edge_type)
+        }
+
+    def test_dict_get_not_resolved(self):
+        """effect.get('value') must NOT create a call to any project symbol."""
+        targets = self._edge_targets_from("dict_method_calls", EdgeType.CALLS)
+        # "effect.get" should not resolve to anything with ".get" in it
+        assert not any(t.endswith(".get") for t in targets), \
+            f"dict.get() false positive: {[t for t in targets if '.get' in t]}"
+
+    def test_dict_items_not_resolved(self):
+        """args.items() must NOT create a call to any project symbol."""
+        targets = self._edge_targets_from("dict_method_calls", EdgeType.CALLS)
+        assert not any(t.endswith(".items") for t in targets), \
+            f"dict.items() false positive: {[t for t in targets if '.items' in t]}"
+
+    def test_list_extend_not_resolved(self):
+        """ops.extend() must NOT resolve to a project symbol."""
+        targets = self._edge_targets_from("dict_method_calls", EdgeType.CALLS)
+        assert not any(t.endswith(".extend") for t in targets), \
+            f"list.extend() false positive: {[t for t in targets if '.extend' in t]}"
+
+    def test_list_append_not_resolved(self):
+        """collected.append() must NOT resolve to a project symbol."""
+        targets = self._edge_targets_from("dict_method_calls", EdgeType.CALLS)
+        assert not any(t.endswith(".append") and "." in t.rsplit(".append", 1)[0] for t in targets), \
+            f"list.append() false positive: {[t for t in targets if '.append' in t]}"
+
+    def test_str_startswith_not_resolved(self):
+        """ref.startswith() must NOT resolve to a project symbol."""
+        targets = self._edge_targets_from("dict_method_calls", EdgeType.CALLS)
+        assert not any(t.endswith(".startswith") for t in targets), \
+            f"str.startswith() false positive: {[t for t in targets if '.startswith' in t]}"
+
+    def test_str_split_not_resolved(self):
+        """ref.split() must NOT resolve to a project symbol."""
+        targets = self._edge_targets_from("dict_method_calls", EdgeType.CALLS)
+        assert not any(t.endswith(".split") for t in targets), \
+            f"str.split() false positive: {[t for t in targets if '.split' in t]}"
+
+    def test_logger_warning_not_resolved(self):
+        """logger.warning() must NOT create edges to project symbols."""
+        targets = self._edge_targets_from("logging_calls", EdgeType.CALLS)
+        # Should not resolve to any project node
+        node_ids = _node_ids(self.graph)
+        resolved_to_project = targets & node_ids
+        bad = {t for t in resolved_to_project if "warning" in t or "error" in t or "info" in t or "debug" in t}
+        assert not bad, \
+            f"logging calls resolved to project symbols: {bad}"
+
+    def test_same_name_helper_resolves_locally(self):
+        """calls_shared_helper() should call THIS module's _shared_helper."""
+        caller = _find(self.graph, "calls_shared_helper")
+        targets = {
+            e.target for e in self.graph.all_edges()
+            if e.source == caller and e.edge_type == EdgeType.CALLS
+        }
+        # Should resolve to false_positive_edges._shared_helper, not another module's
+        local_match = [t for t in targets if "false_positive_edges._shared_helper" in t]
+        foreign_match = [t for t in targets if "_shared_helper" in t and "false_positive_edges" not in t]
+        assert local_match, \
+            f"calls_shared_helper should call local _shared_helper, got: {targets}"
+        assert not foreign_match, \
+            f"calls_shared_helper resolved to foreign _shared_helper: {foreign_match}"
+
+
 class TestMCPFidelity:
     """Verify MCP dispatch produces the same results as direct engine calls."""