codegraphcontext 0.6.4__tar.gz → 0.6.6__tar.gz

{codegraphcontext-0.6.4/src/codegraphcontext.egg-info → codegraphcontext-0.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.6.4
+Version: 0.6.6
 Summary: An MCP server that indexes local code into a graph database to provide context to AI assistants.
 Author-email: Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 License: MIT License
@@ -258,7 +258,12 @@ flowchart LR
 ---
 
 ## Star History
-[![Star History Chart](https://api.star-history.com/svg?repos=CodeGraphContext/CodeGraphContext&type=Date)](https://www.star-history.com/#CodeGraphContext/CodeGraphContext&Date)
+[Star History Chart ↗](https://www.star-history.com/#CodeGraphContext/CodeGraphContext&Date)
+<!-- The inline chart image is temporarily removed: api.star-history.com currently
+     renders "GitHub restricted access to star data" instead of the chart
+     (GitHub-side restriction, see PR #1642). Restore the image once the
+     official service recovers:
+     [![Star History Chart](https://api.star-history.com/svg?repos=CodeGraphContext/CodeGraphContext&type=Date)](https://www.star-history.com/#CodeGraphContext/CodeGraphContext&Date) -->
 
 ---
 

{codegraphcontext-0.6.4 → codegraphcontext-0.6.6}/README.md

@@ -159,7 +159,12 @@ flowchart LR
 ---
 
 ## Star History
-[![Star History Chart](https://api.star-history.com/svg?repos=CodeGraphContext/CodeGraphContext&type=Date)](https://www.star-history.com/#CodeGraphContext/CodeGraphContext&Date)
+[Star History Chart ↗](https://www.star-history.com/#CodeGraphContext/CodeGraphContext&Date)
+<!-- The inline chart image is temporarily removed: api.star-history.com currently
+     renders "GitHub restricted access to star data" instead of the chart
+     (GitHub-side restriction, see PR #1642). Restore the image once the
+     official service recovers:
+     [![Star History Chart](https://api.star-history.com/svg?repos=CodeGraphContext/CodeGraphContext&type=Date)](https://www.star-history.com/#CodeGraphContext/CodeGraphContext&Date) -->
 
 ---
 

{codegraphcontext-0.6.4 → codegraphcontext-0.6.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.6.4"
+version = "0.6.6"
 description = "An MCP server that indexes local code into a graph database to provide context to AI assistants."
 authors = [{ name = "Shashank Shekhar Singh", email = "shashankshekharsingh1205@gmail.com" }]
 readme = "README.md"

{codegraphcontext-0.6.4 → codegraphcontext-0.6.6}/src/codegraphcontext/tools/indexing/persistence/writer.py

@@ -68,6 +68,29 @@ _NAME_ONLY_MERGE_LABELS = {"Module", "DbTable", "ExternalClass"}
 # repeated mentions, and merging them is exactly the pre-#1393 behaviour.
 _COALESCE_SAME_KEY_LABELS = {"Variable"}
 
+# Node types that mean "the enclosing declaration is a FUNCTION" across the
+# tree-sitter grammars. The nested-function CONTAINS batch used to gate on the
+# literal Python type 'function_definition', which only python.py emits — every
+# other language that populated context_type (TS, and now JS) silently lost its
+# nested-function containment edges (#1538).
+_FUNCTION_CONTEXT_TYPES = {
+    "function_definition",            # python, cpp, php
+    "function_declaration",           # js/ts, go, kotlin, lua
+    "function_expression",            # js/ts
+    "arrow_function",                 # js/ts
+    "generator_function",             # js/ts
+    "generator_function_declaration", # js/ts
+    "method_definition",              # js/ts
+    "method_declaration",             # java, csharp, go
+    "constructor_declaration",        # java
+    "local_function_statement",       # csharp
+    "func_literal",                   # go
+    "function_item",                  # rust
+    "method",                         # ruby
+    "singleton_method",               # ruby
+    "lambda_expression",              # cpp, java
+}
+
 
 def _coalesce_same_key_items(items: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
     """Fold records sharing (name, line_number) into one, in write order."""
@@ -131,14 +154,30 @@ def _cypher_label(label: str, backend: str) -> str:
 
 
 def _called_context_clause(called_label: str) -> str:
-    """Match CALLS targets that store scope in context, class_context, or module_context."""
-    if called_label in ("Function", "Variable"):
+    """Match CALLS targets that store scope in context, class_context, or module_context.
+
+    Resolution stores the resolved scope in `called_context`, but which node
+    property carries that scope differs by parser: Python/JS use `context`,
+    C++/PHP methods use `class_context`, and Rust functions carry ONLY
+    `module_context` (#1510). Matching `context` alone filtered every
+    correctly-resolved Rust module-scoped call out at write time.
+
+    Variable is restricted to `context`: the Kùzu Variable table declares no
+    class_context/module_context columns, and referencing a missing column
+    binder-errors the whole batch on typed backends.
+    """
+    if called_label == "Function":
         return (
             'AND (row.called_context = "" OR row.called_context IS NULL '
             "OR called.context = row.called_context "
             "OR called.class_context = row.called_context "
             "OR called.module_context = row.called_context)"
         )
+    if called_label == "Variable":
+        return (
+            'AND (row.called_context = "" OR row.called_context IS NULL '
+            "OR called.context = row.called_context)"
+        )
     return ""
 
 
@@ -467,7 +506,7 @@ class GraphWriter:
                                     "func_line": item["line_number"],
                                 }
                             )
-                        if item.get("context_type") == "function_definition":
+                        if item.get("context_type") in _FUNCTION_CONTEXT_TYPES:
                             outer_ctx = item.get("context")
                             is_seq = isinstance(outer_ctx, (tuple, list)) and outer_ctx
                             outer_name = outer_ctx[0] if is_seq else outer_ctx
@@ -983,10 +1022,12 @@ class GraphWriter:
                         precise_batch.append(row)
 
                 # Define which labels have a 'context' property in the schema
-                labels_with_context = {"Function", "Variable"}
-                called_context_clause = ""
-                if called_label in labels_with_context:
-                    called_context_clause = 'AND (row.called_context = "" OR called.context = row.called_context)'
+                # The label-aware helper matches context, class_context or
+                # module_context depending on what the label's parsers emit —
+                # the inline context-only predicate silently dropped Rust
+                # module-scoped calls whose functions carry only
+                # module_context (#1510).
+                called_context_clause = _called_context_clause(called_label)
 
                 # ...and which have a 'line_number'. File and Directory do not:
                 # the Kùzu File table is (path, name, relative_path, package_name,

{codegraphcontext-0.6.4 → codegraphcontext-0.6.6}/src/codegraphcontext/tools/indexing/schema.py

@@ -137,6 +137,35 @@ def create_graph_schema(driver: Any, db_manager: Any) -> None:
                 ddl.run(
                     "CREATE CONSTRAINT annotation_unique IF NOT EXISTS FOR (a:Annotation) REQUIRE (a.name, a.path, a.line_number) IS UNIQUE"
                 )
+                # The relationship passes and code_finder look these nodes up
+                # by (name, path) with no line_number: write_inheritance_links
+                # matches `(child:<Label> {name: row.child_name, path:
+                # row.path})`, and the same for the parent, for every label
+                # pair it enumerates; write_function_call_groups matches the
+                # callee by (name, path) in both the batched and the single-row
+                # path; and code_finder's who_calls_function,
+                # what_does_function_call, find_class_hierarchy,
+                # find_all_callers and find_all_callees do the same.
+                #
+                # Neo4j uses a composite index only when EVERY indexed property
+                # has a predicate, so the four-property identity constraints
+                # above cannot serve those lookups -- the planner falls back to
+                # NodeByLabelScan + Filter, once per row. These plain
+                # two-property indexes restore an index seek. They do not
+                # collide with the identity constraints: a constraint's backing
+                # index covers a different property set, so the two coexist.
+                #
+                # FalkorDB is excluded (this is inside `not is_falkordb`): it
+                # indexes per attribute, not per property tuple, and the
+                # composite CREATE INDEX statements in its own branch already
+                # cover name and path. A second (name, path) index would add
+                # nothing there and only re-issue an index creation FalkorDB
+                # rejects as "already indexed".
+                for _label, _var in POSITIONAL_IDENTITY_LABELS.items():
+                    ddl.run(
+                        f"CREATE INDEX {_label.lower()}_name_path IF NOT EXISTS "
+                        f"FOR ({_var}:{_label}) ON ({_var}.name, {_var}.path)"
+                    )
 
             ddl.run("CREATE INDEX function_lang IF NOT EXISTS FOR (f:Function) ON (f.lang)")
             ddl.run("CREATE INDEX class_lang IF NOT EXISTS FOR (c:Class) ON (c.lang)")

{codegraphcontext-0.6.4 → codegraphcontext-0.6.6}/src/codegraphcontext/tools/languages/c.py

@@ -139,9 +139,14 @@ C_QUERIES = {
         )
     """,
     "macros": """
-        (preproc_def
-            name: (identifier) @name
-        ) @macro
+        [
+            (preproc_def
+                name: (identifier) @name
+            )
+            (preproc_function_def
+                name: (identifier) @name
+            )
+        ] @macro
     """,
 }
 
@@ -512,46 +517,53 @@ class CTreeSitterParser:
         members: List[Dict[str, Any]] = []
         seen_names: set[str] = set()
 
-        for enum_cls in classes:
-            if enum_cls.get("type") != "enum":
+        # One structural pass over every enum body (#1538). The old version
+        # had two compounding bugs: the `(enumerator)*` quantifier made only
+        # the FIRST enumerator of each enum match, and the whole-file query
+        # re-ran inside a per-enum loop with a global seen set — so the first
+        # enum claimed every member (`OK` from `enum Status` was emitted with
+        # enum_name 'Color').
+        enums_by_line = {
+            enum_cls.get("line_number"): enum_cls
+            for enum_cls in classes
+            if enum_cls.get("type") == "enum" and enum_cls.get("name")
+        }
+        for match in execute_query(
+            self.language, "(enum_specifier) @enum", root_node
+        ):
+            enum_node = match[0]
+            enum_cls = enums_by_line.get(enum_node.start_point[0] + 1)
+            if not enum_cls:
                 continue
-            enum_name = enum_cls.get("name")
-            if not enum_name:
+            enum_name = enum_cls["name"]
+            body = enum_node.child_by_field_name("body")
+            if body is None:
                 continue
-
-            for match in execute_query(
-                self.language,
-                """
-                (enum_specifier
-                    body: (enumerator_list
-                        (enumerator
-                            name: (identifier) @member
-                        )*
-                    )
-                )
-                """,
-                root_node,
-            ):
-                if match[1] != "member":
+            for child in body.children:
+                if child.type != "enumerator":
+                    continue
+                name_node = child.child_by_field_name("name")
+                if name_node is None:
                     continue
-                member_name = self._get_node_text(match[0])
-                if member_name in seen_names:
+                member_name = self._get_node_text(name_node)
+                if (enum_name, member_name) in seen_names:
                     continue
-                seen_names.add(member_name)
+                seen_names.add((enum_name, member_name))
                 members.append({
                     "name": member_name,
                     "enum_name": enum_name,
                     "enum_line_number": enum_cls.get("line_number"),
-                    "line_number": match[0].start_point[0] + 1,
+                    "line_number": name_node.start_point[0] + 1,
                     "lang": self.language_name,
                     "is_dependency": False,
                 })
 
         x_macro_members = self._find_xmacro_enum_members(source_code, classes, macros)
         for member in x_macro_members:
-            if member["name"] in seen_names:
+            key = (member.get("enum_name"), member["name"])
+            if key in seen_names:
                 continue
-            seen_names.add(member["name"])
+            seen_names.add(key)
             members.append(member)
 
         return members
@@ -752,10 +764,14 @@ class CTreeSitterParser:
                 
                 context, context_type, _ = self._get_parent_context(macro_node)
                 
+                # A preproc node's end_point includes the trailing newline
+                # (lands at column 0 of the NEXT row), so +1 double-counts.
+                end_row = macro_node.end_point[0]
+                end_col = macro_node.end_point[1]
                 macro_data = {
                     "name": name,
                     "line_number": node.start_point[0] + 1,
-                    "end_line": macro_node.end_point[0] + 1,
+                    "end_line": end_row if end_col == 0 else end_row + 1,
                     "value": value,
                     "params": params,
                     "context": context,

{codegraphcontext-0.6.4 → codegraphcontext-0.6.6}/src/codegraphcontext/tools/languages/csharp.py

@@ -230,11 +230,16 @@ class CSharpTreeSitterParser:
                             params_node = params_captures[0][0]
                             parameters = self._extract_parameters(params_node)
 
-                        # Extract attributes applied to this function
+                        # Extract attributes applied to this function.
+                        # attribute_list nodes are CHILDREN of the declaration
+                        # (never its parent), so the old parent check was
+                        # always false and attributes stayed [] (#1538).
                         attributes = []
-                        if node.parent and node.parent.type == "attribute_list":
-                            attr_text = self._get_node_text(node.parent)
-                            attributes.append(attr_text)
+                        for child in node.children:
+                            if child.type == "attribute_list":
+                                for attr in child.children:
+                                    if attr.type == "attribute":
+                                        attributes.append(self._get_node_text(attr))
 
                         # Find containing class/struct/interface
                         class_context = self._find_containing_type(node, source_code)
@@ -245,7 +250,9 @@ class CSharpTreeSitterParser:
                             "name": func_name,
                             "args": parameters,
                             "attributes": attributes,
-                            "line_number": start_line,
+                            # The declaration line, not the first attribute's
+                            # (python.py's decorated_definition convention).
+                            "line_number": name_node.start_point[0] + 1,
                             "end_line": end_line,
                             "path": str(path),
                             "lang": self.language_name,
@@ -491,8 +498,11 @@ class CSharpTreeSitterParser:
                     call_name = self._get_node_text(node)
                     line_number = node.start_point[0] + 1
                     
-                    # Avoid duplicates at the same line for the same name
-                    call_key = f"{call_name}_{line_number}"
+                    # Dedupe per CALL SITE, not per (name, line): keying on
+                    # name_line dropped distinct calls to the same function on
+                    # one line — `Math.Max(Clamp(a), Clamp(b))` recorded ONE
+                    # Clamp (#1538). The node's byte offset separates them.
+                    call_key = (call_name, line_number, node.start_byte)
                     if call_key in seen_calls:
                         continue
                     seen_calls.add(call_key)
@@ -504,7 +514,16 @@ class CSharpTreeSitterParser:
                     
                     # Get context
                     context_name, context_type, context_line = self._get_parent_context(node)
-                    class_context = context_name if context_type and 'class' in context_type else None
+                    # A call's first enclosing declaration is its METHOD, so
+                    # `'class' in context_type` was always false and every
+                    # call's class_context was None (#1538). Walk again for
+                    # class-like ancestors only, cpp-style.
+                    cls_name, _cls_type, cls_line = self._get_parent_context(
+                        node,
+                        types=("class_declaration", "struct_declaration",
+                               "record_declaration", "interface_declaration"),
+                    )
+                    class_context = (cls_name, cls_line) if cls_name else None
 
                     call_data = {
                         "name": call_name,

{codegraphcontext-0.6.4 → codegraphcontext-0.6.6}/src/codegraphcontext/tools/languages/elixir.py

@@ -465,6 +465,28 @@ class ElixirTreeSitterParser:
                     "is_dependency": False,
                 })
 
+        # A `def hello(x) do ... end` is itself a `call` node whose arguments
+        # contain the SIGNATURE as a nested call. Recursing blindly recorded
+        # every definition head as an invocation — a false self-recursive
+        # CALLS edge on every Elixir function (#1538). For definition calls,
+        # skip the signature and recurse only into the body.
+        if node.type == 'call':
+            head_identifier = next(
+                (c for c in node.children if c.type == 'identifier'), None
+            )
+            head_target = self._get_node_text(head_identifier) if head_identifier else None
+            if head_target in FUNCTION_KEYWORDS:
+                for child in node.children:
+                    if child.type == 'do_block':
+                        self._find_calls_recursive(child, calls)
+                    elif child.type == 'arguments':
+                        # Skip the signature (the first nested call) but keep
+                        # the inline `, do: body` keywords — that IS the body.
+                        for arg in child.children:
+                            if arg.type != 'call':
+                                self._find_calls_recursive(arg, calls)
+                return
+
         for child in node.children:
             self._find_calls_recursive(child, calls)
 

{codegraphcontext-0.6.4 → codegraphcontext-0.6.6}/src/codegraphcontext/tools/languages/haskell.py

@@ -201,13 +201,17 @@ class HaskellTreeSitterParser:
             "lang": self.language_name,
         }
 
-    def _apply_callee_name(self, apply_node: Any) -> Optional[str]:
+    def _apply_callee(self, apply_node: Any) -> Optional[Any]:
         fn = apply_node.child_by_field_name("function")
         while fn and fn.type == "apply":
             fn = fn.child_by_field_name("function")
         if not fn or fn.type not in ("variable", "constructor"):
             return None
-        return self._get_node_text(fn) or None
+        return fn
+
+    def _apply_callee_name(self, apply_node: Any) -> Optional[str]:
+        fn = self._apply_callee(apply_node)
+        return (self._get_node_text(fn) or None) if fn is not None else None
 
     def _parse_instances(
         self, captures: List[Tuple[Any, str]], source_code: str, path: Path
@@ -448,10 +452,15 @@ class HaskellTreeSitterParser:
         for node, cap in captures:
             if cap != "apply_node" or node.type != "apply":
                 continue
-            call_name = self._apply_callee_name(node)
+            callee = self._apply_callee(node)
+            call_name = (self._get_node_text(callee) or None) if callee is not None else None
             if not call_name:
                 continue
-            key = (node.start_byte, node.end_byte)
+            # Dedupe by the CALLEE node: curried application produces nested
+            # apply nodes with distinct spans for one call — `print (addTwo
+            # 1 2)` emitted addTwo twice at the same line (#1538). Both
+            # applies share the same callee identifier node.
+            key = (callee.start_byte, callee.end_byte)
             if key in seen_calls:
                 continue
             seen_calls.add(key)

{codegraphcontext-0.6.4 → codegraphcontext-0.6.6}/src/codegraphcontext/tools/languages/java.py

@@ -270,9 +270,28 @@ class JavaTreeSitterParser:
                 "lang": self.language_name,
             }
 
-    def _get_parent_context(self, node: Any) -> Tuple[Optional[str], Optional[str], Optional[int]]:
+    def _get_parent_context(self, node: Any, types: Optional[Tuple[str, ...]] = None) -> Tuple[Optional[str], Optional[str], Optional[int]]:
+        """First enclosing declaration; pass `types` to look only for those.
+
+        A call inside a method always has the method as its FIRST enclosing
+        declaration, so without `types` the class branch below can never win —
+        which left every call's class_context structurally (None, None) and
+        the super()/same-name-method resolution paths dead (#1538). Callers
+        that want the enclosing class pass types=("class_declaration", ...),
+        the same pattern cpp.py uses.
+        """
         curr = node.parent
         while curr:
+            if types is not None:
+                if curr.type in types:
+                    name_node = curr.child_by_field_name("name")
+                    return (
+                        self._get_node_text(name_node) if name_node else None,
+                        curr.type,
+                        curr.start_point[0] + 1,
+                    )
+                curr = curr.parent
+                continue
             if curr.type in ("method_declaration", "constructor_declaration"):
                 name_node = curr.child_by_field_name("name")
                 return (
@@ -941,6 +960,11 @@ class JavaTreeSitterParser:
                             full_name = self._get_node_text(type_node)
 
                     ctx_name, ctx_type, ctx_line = self._get_parent_context(node)
+                    cls_name, cls_type, cls_line = self._get_parent_context(
+                        node,
+                        types=("class_declaration", "interface_declaration",
+                               "enum_declaration", "annotation_type_declaration"),
+                    )
 
                     debug_log(f"Found call: {call_name} (full_name: {full_name}, inferred_obj_type: {inferred_obj_type}, args: {args}) in context {ctx_name}")
 
@@ -951,7 +975,7 @@ class JavaTreeSitterParser:
                         "args": args,
                         "inferred_obj_type": inferred_obj_type,
                         "context": (ctx_name, ctx_type, ctx_line),
-                        "class_context": (ctx_name, ctx_line) if ctx_type in ("class_declaration", "interface_declaration", "enum_declaration", "annotation_type_declaration") else (None, None),
+                        "class_context": (cls_name, cls_line) if cls_name else None,
                         "lang": self.language_name,
                         "is_dependency": False,
                     }

{codegraphcontext-0.6.4 → codegraphcontext-0.6.6}/src/codegraphcontext/tools/languages/javascript.py

@@ -298,7 +298,7 @@ class JavascriptTreeSitterParser:
                 args = [self._get_node_text(data['single_param'])]
 
             # Context & docstring
-            context, context_type, _ = self._get_parent_context(func_node)
+            context, context_type, context_line = self._get_parent_context(func_node)
             class_context = context if context_type == 'class_declaration' else None
             docstring = self._get_jsdoc_comment(func_node)
 
@@ -314,6 +314,14 @@ class JavascriptTreeSitterParser:
                 "end_line": func_node.end_point[0] + 1,
                 "args": args,
                 "class_context": class_context,
+                # context/context_type were computed and then dropped, so a
+                # nested function never got a CONTAINS edge to its enclosing
+                # function (#1538). Function rows carry context as a BARE NAME
+                # plus separate type/line fields — the tuple shape belongs to
+                # call rows only (python.py is the reference).
+                "context": context,
+                "context_type": context_type,
+                "context_line": context_line,
                 "lang": self.language_name,
                 "is_dependency": False,
                 "cyclomatic_complexity": self._calculate_complexity(func_node),

{codegraphcontext-0.6.4 → codegraphcontext-0.6.6}/src/codegraphcontext/tools/languages/php.py

@@ -30,6 +30,10 @@ PHP_QUERIES = {
         (trait_declaration
             name: (name) @name
         ) @trait
+
+        (enum_declaration
+            name: (name) @name
+        ) @enum
     """,
     # A top-level `use App\Models\User;` is a `namespace_use_declaration`.
     # `use_declaration` is the *trait* use inside a class body (relied on at
@@ -153,7 +157,7 @@ class PhpTreeSitterParser:
     def _get_parent_context(self, node: Any) -> Tuple[Optional[str], Optional[str], Optional[int]]:
         curr = node.parent
         while curr:
-            if curr.type in ("function_definition", "method_declaration", "class_declaration", "interface_declaration", "trait_declaration"):
+            if curr.type in ("function_definition", "method_declaration", "class_declaration", "interface_declaration", "trait_declaration", "enum_declaration"):
                 name_node = curr.child_by_field_name("name")
                 return (
                     self._get_node_text(name_node) if name_node else None,
@@ -166,12 +170,29 @@ class PhpTreeSitterParser:
     def _get_enclosing_class_name(self, node: Any) -> Optional[str]:
         curr = node.parent
         while curr:
-            if curr.type in ("class_declaration", "interface_declaration", "trait_declaration"):
+            if curr.type in ("class_declaration", "interface_declaration", "trait_declaration", "enum_declaration"):
                 name_node = curr.child_by_field_name("name")
                 return self._get_node_text(name_node) if name_node else None
             curr = curr.parent
         return None
 
+    def _get_enclosing_class(self, node: Any) -> Optional[Tuple[str, int]]:
+        """(name, line) of the enclosing class-like declaration, or None.
+
+        Calls previously emitted TWO shapes for class_context — a bare string
+        for ordinary calls and a dead (None, None) tuple for `new X()` (the
+        parent-context type is the enclosing *function*, never a class) — so
+        the tuple-consuming resolution paths never fired for PHP (#1538).
+        """
+        curr = node.parent
+        while curr:
+            if curr.type in ("class_declaration", "interface_declaration", "trait_declaration", "enum_declaration"):
+                name_node = curr.child_by_field_name("name")
+                name = self._get_node_text(name_node) if name_node else None
+                return (name, curr.start_point[0] + 1) if name else None
+            curr = curr.parent
+        return None
+
     def _get_node_text(self, node: Any) -> str:
         if not node: return ""
         return node.text.decode("utf-8")
@@ -266,7 +287,7 @@ class PhpTreeSitterParser:
                             "lang": self.language_name,
                             "context": context_name,
                             "context_type": context_type,
-                            "class_context": context_name if context_type and ("class" in context_type or "interface" in context_type or "trait" in context_type) else None
+                            "class_context": context_name if context_type and ("class" in context_type or "interface" in context_type or "trait" in context_type or "enum" in context_type) else None
                         }
                         
                         if self.index_source:
@@ -287,7 +308,7 @@ class PhpTreeSitterParser:
         seen_nodes = set()
 
         for node, capture_name in captures:
-            if capture_name in ("class", "interface", "trait"):
+            if capture_name in ("class", "interface", "trait", "enum"):
                 node_id = (node.start_byte, node.end_byte, node.type)
                 if node_id in seen_nodes:
                     continue
@@ -350,6 +371,12 @@ class PhpTreeSitterParser:
                             interfaces.append(type_data)
                         elif capture_name == "trait":
                             traits.append(type_data)
+                        elif capture_name == "enum":
+                            # PHP 8.1 enums are class-likes: without this arm
+                            # the captured row was silently dropped and enum
+                            # methods became orphans (#1538).
+                            type_data["node_type"] = "enum"
+                            classes.append(type_data)
                         
                 except Exception as e:
                     error_logger(f"Error parsing type in {path}: {e}")
@@ -398,7 +425,7 @@ class PhpTreeSitterParser:
                         "path": str(path),
                         "lang": self.language_name,
                         "context": ctx_name,
-                        "class_context": ctx_name if ctx_type and ("class" in ctx_type or "interface" in ctx_type or "trait" in ctx_type) else None
+                        "class_context": ctx_name if ctx_type and ("class" in ctx_type or "interface" in ctx_type or "trait" in ctx_type or "enum" in ctx_type) else None
                      })
                 except Exception as e:
                     continue
@@ -558,7 +585,7 @@ class PhpTreeSitterParser:
                         "args": args,
                         "inferred_obj_type": inferred_obj_type,
                         "context": (ctx_name, ctx_type, ctx_line),
-                        "class_context": self._get_enclosing_class_name(node),
+                        "class_context": self._get_enclosing_class(node),
                         "lang": self.language_name,
                         "is_dependency": False,
                     }
@@ -607,7 +634,7 @@ class PhpTreeSitterParser:
                         "args": args,
                         "inferred_obj_type": None,
                         "context": (ctx_name, ctx_type, ctx_line),
-                        "class_context": (ctx_name, ctx_line) if ctx_type and ("class" in ctx_type or "interface" in ctx_type or "trait" in ctx_type) else (None, None),
+                        "class_context": self._get_enclosing_class(node),
                         "lang": self.language_name,
                         "is_dependency": False,
                     }

{codegraphcontext-0.6.4 → codegraphcontext-0.6.6}/src/codegraphcontext/tools/languages/ruby.py

@@ -480,13 +480,18 @@ class RubyTreeSitterParser:
                         captures_by_call[call_id]['name'] = self._get_node_text(node)
                 
                 elif capture_name == 'receiver':
-                    captures_by_call[call_id]['receiver'] = self._get_node_text(node)
+                    # Field check, like the name branch: byte-range containment
+                    # alone let nested calls steal each other's receiver —
+                    # `logger.info(formatter.render(x))` recorded `info` with
+                    # full_name "formatter.info" (#1538).
+                    if node == call_node.child_by_field_name('receiver'):
+                        captures_by_call[call_id]['receiver'] = self._get_node_text(node)
                 
                 elif capture_name == 'args':
-                     # Capture arguments
-                    args_text = self._get_node_text(node)
-                    # Simple heuristic: split by comma
-                    captures_by_call[call_id]['args'] = [a.strip() for a in args_text.strip("()").split(',') if a.strip()]
+                    if node == call_node.child_by_field_name('arguments'):
+                        args_text = self._get_node_text(node)
+                        # Simple heuristic: split by comma
+                        captures_by_call[call_id]['args'] = [a.strip() for a in args_text.strip("()").split(',') if a.strip()]
 
         for call_data in captures_by_call.values():
             call_node = call_data['node']