codegraphcontext 0.6.4__tar.gz → 0.6.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.6.4
+Version: 0.6.5
 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

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

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.6.4"
+version = "0.6.5"
 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.5}/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."""
@@ -467,7 +490,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

{codegraphcontext-0.6.4 → codegraphcontext-0.6.5}/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.5}/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.5}/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.5}/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.5}/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.5}/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.5}/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.5}/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']

{codegraphcontext-0.6.4 → codegraphcontext-0.6.5}/src/codegraphcontext/tools/languages/rust.py

@@ -150,6 +150,24 @@ class RustTreeSitterParser:
                     params.append(arg_str)
 
                 module_context = self._module_path_for_node(func_node)
+
+                # impl methods carried only module_context, so Point::new was
+                # never linked to Point and impl methods showed up as orphan
+                # functions (#1538). The impl_item's `type` field is the
+                # implementing type for both inherent (`impl Point`) and
+                # trait (`impl Draw for Point`) blocks.
+                class_context = None
+                class_context_line = None
+                curr = func_node.parent
+                while curr:
+                    if curr.type == "impl_item":
+                        type_node = curr.child_by_field_name("type")
+                        if type_node is not None:
+                            class_context = self._get_node_text(type_node)
+                            class_context_line = curr.start_point[0] + 1
+                        break
+                    curr = curr.parent
+
                 func_data = {
                     "name": name,
                     "line_number": name_node.start_point[0] + 1,
@@ -157,6 +175,8 @@ class RustTreeSitterParser:
                     "params": params,
                     "args": params,
                     "module_context": module_context,
+                    "class_context": class_context,
+                    "class_context_line": class_context_line,
                     "is_extern": False,
                     "lang": self.language_name,
                     "is_dependency": False,
@@ -374,12 +394,28 @@ class RustTreeSitterParser:
                             if child.type not in ('(', ')', ','):
                                 args.append(self._get_node_text(child))
 
+                # For `Type::method()` the scope is the receiver type — now
+                # that impl methods carry class_context (#1538), handing the
+                # scope to resolution lets it pick the RIGHT `new` among many
+                # same-named impl methods instead of guessing (or, worse,
+                # binding Arc::new/Box::new to an unrelated local `new`).
+                inferred_obj_type = None
+                if call_node and call_node.type == 'call_expression':
+                    fn_node = call_node.child_by_field_name('function')
+                    if fn_node is not None and fn_node.type == 'scoped_identifier':
+                        scope_node = fn_node.child_by_field_name('path')
+                        if scope_node is not None:
+                            scope_text = self._get_node_text(scope_node)
+                            # `Vec::<T>::new` styles: keep the last plain segment
+                            inferred_obj_type = scope_text.split('::')[-1] or None
+
                 calls.append(
                     {
                         "name": call_name,
                         "full_name": self._get_node_text(call_node) if call_node else call_name,
                         "line_number": node.start_point[0] + 1,
                         "args": args,
+                        "inferred_obj_type": inferred_obj_type,
                         "context": self._get_parent_context(node),
                         "lang": self.language_name,
                         "is_dependency": False,

{codegraphcontext-0.6.4 → codegraphcontext-0.6.5}/src/codegraphcontext/tools/languages/swift.py

@@ -127,9 +127,12 @@ class SwiftTreeSitterParser:
                 "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]]:
         curr = node.parent
         while curr:
+            if types is not None and curr.type not in types:
+                curr = curr.parent
+                continue
             if curr.type == "function_declaration":
                 name_node = curr.child_by_field_name("name")
                 if not name_node:
@@ -557,18 +560,39 @@ class SwiftTreeSitterParser:
                                     inferred_type = vtype
                                     break
 
+                    # Both were audit findings (#1538): class_context was
+                    # hardcoded (None, None) — dead for super/self resolution —
+                    # and args was hardcoded [].
+                    cls_name, _cls_type, cls_line = self._get_parent_context(
+                        node,
+                        types=("class_declaration", "struct_declaration",
+                               "enum_declaration", "protocol_declaration",
+                               "extension_declaration"),
+                    )
+                    args = []
+                    for child in node.children:
+                        if child.type == "call_suffix":
+                            for va in child.children:
+                                if va.type == "value_arguments":
+                                    for arg in va.children:
+                                        if arg.type == "value_argument":
+                                            args.append(self._get_node_text(arg))
+
                     calls.append({
                         "name": call_name,
                         "full_name": full_name,
                         "line_number": start_line,
-                        "args": [],
+                        "args": args,
                         "inferred_obj_type": inferred_type,
                         "context": (ctx_name, ctx_type, ctx_line),
-                        "class_context": (None, None),
+                        "class_context": (cls_name, cls_line) if cls_name else None,
                         "lang": self.language_name,
                         "is_dependency": False
                     })
                 except Exception as e:
+                    # A bare continue swallowed every extraction failure with
+                    # no trace at all (#1538); keep indexing but say so.
+                    debug_log(f"Swift call extraction failed at line {node.start_point[0] + 1}: {e}")
                     continue
         return calls
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.6.4
+Version: 0.6.5
 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