codegraphcontext 0.6.3__tar.gz → 0.6.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.6.3
+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.3 → codegraphcontext-0.6.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.6.3"
+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.3 → codegraphcontext-0.6.5}/src/codegraphcontext/cli/main.py

@@ -1178,14 +1178,22 @@ def diagram(
     if level not in ("file", "call"):
         console.print(f"[red]Unknown --level '{level}' (expected file or call)[/red]")
         raise typer.Exit(code=2)
+    # stdout carries only the diagram; init chatter goes to stderr for the
+    # init window only (restored after — a permanent rebind leaks a closed
+    # stream into later in-process invocations).
+    import sys as _sys
+    from . import cli_helpers as _cli_helpers
+    # NB: the .file property GETTER materializes the current (possibly
+    # transient, CliRunner-captured) stream; the dynamic state lives in
+    # ._file, which is None while the console follows sys.stdout live.
+    _prev_console_file = _cli_helpers.console._file
     if output is None:
-        # stdout carries only the diagram; init chatter goes to stderr.
-        import sys as _sys
-        from . import cli_helpers as _cli_helpers
         _cli_helpers.console.file = _sys.stderr
-
-    _load_credentials()
-    services = _initialize_services(context)
+    try:
+        _load_credentials()
+        services = _initialize_services(context)
+    finally:
+        _cli_helpers.console._file = _prev_console_file
     if not all(services[:3]):
         raise typer.Exit(code=1)
     db_manager, graph_builder, code_finder = services[:3]
@@ -3018,15 +3026,24 @@ def analyze_complexity(
     if output_format not in ("text", "json", "csv"):
         console.print(f"[red]Unknown --format '{output_format}' (expected text, json or csv)[/red]")
         raise typer.Exit(code=2)
+    # stdout must carry ONLY the parseable document in machine formats: the
+    # service-init chatter from cli_helpers prints to stdout, so reroute that
+    # console to stderr FOR THE INIT WINDOW ONLY (`--format json | jq .`).
+    # The rebind must be restored — a permanent one leaks a closed stream into
+    # later in-process invocations (CliRunner-based tests).
+    import sys as _sys
+    from . import cli_helpers as _cli_helpers
+    # NB: the .file property GETTER materializes the current (possibly
+    # transient, CliRunner-captured) stream; the dynamic state lives in
+    # ._file, which is None while the console follows sys.stdout live.
+    _prev_console_file = _cli_helpers.console._file
     if output_format in ("json", "csv"):
-        # stdout must carry ONLY the parseable document: the service-init
-        # chatter from cli_helpers prints to stdout, so reroute that console
-        # to stderr before initializing anything (`--format json | jq .`).
-        import sys as _sys
-        from . import cli_helpers as _cli_helpers
         _cli_helpers.console.file = _sys.stderr
-    _load_credentials()
-    services = _initialize_services(context)
+    try:
+        _load_credentials()
+        services = _initialize_services(context)
+    finally:
+        _cli_helpers.console._file = _prev_console_file
     if not all(services[:3]):
         raise typer.Exit(code=1)
     db_manager, graph_builder, code_finder = services[:3]

{codegraphcontext-0.6.3 → 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
@@ -1137,6 +1160,8 @@ class GraphWriter:
         )
         batch_size = 500
         backend = get_backend_type(self.driver, self._db_manager)
+        labels = ("Class", "Trait", "Interface", "Struct", "Enum", "Union", "Record", "Mixin", "Extension", "Module", "Object", "Variable")
+
         def _work(session):
             # Dedupe identical rows first: parsers can emit the same
             # (child, parent) record more than once, and while Neo4j's MERGE
@@ -1156,8 +1181,6 @@ class GraphWriter:
             internal_batch = [r for r in deduped_batch if r.get("resolved_parent_file_path") != "__external__"]
             external_batch = [r for r in deduped_batch if r.get("resolved_parent_file_path") == "__external__"]
 
-            labels = ("Class", "Trait", "Interface", "Struct", "Enum", "Union", "Record", "Mixin", "Extension", "Module", "Object", "Variable")
-
             def _label_is_populated(label: str) -> bool:
                 # An empty node table can never match, so skip the pair entirely.
                 # If the existence probe itself fails for any reason, fall back to
@@ -1170,52 +1193,109 @@ class GraphWriter:
                 except Exception:
                     return True
 
+            # Probed once (~12 queries) and reused by the *fallback* enumerations
+            # further down. Deliberately NOT applied to `pair_groups`: those
+            # (child_label, parent_label) pairs are derived from the rows
+            # themselves, so they are never empty -- probing them would be pure
+            # overhead, and a stale or lazily-created label table would make the
+            # probe silently drop real INHERITS edges.
             populated_labels = {label for label in labels if _label_is_populated(label)}
 
-            for child_label in labels:
-                if child_label not in populated_labels:
-                    continue
+            def _chunks(rows):
+                for i in range(0, len(rows), batch_size):
+                    yield rows[i:i + batch_size]
+
+            def _run_internal(rows, child_label, parent_label):
                 child_cypher = _cypher_label(child_label, backend)
-                for parent_label in labels:
-                    if parent_label not in populated_labels:
-                        continue
-                    parent_cypher = _cypher_label(parent_label, backend)
+                parent_cypher = _cypher_label(parent_label, backend)
+                query = f"""
+                    UNWIND $batch AS row
+                    MATCH (child:{child_cypher} {{name: row.child_name, path: row.path}})
+                    MATCH (parent:{parent_cypher} {{name: row.parent_name, path: row.resolved_parent_file_path}})
+                    MERGE (child)-[r:INHERITS]->(parent)
+                    SET r.confidence_label = coalesce(row.confidence_label, 'EXTRACTED')
+                """
+                for chunk in _chunks(rows):
                     try:
-                        session.run(
-                            f"""
-                            UNWIND $batch AS row
-                            MATCH (child:{child_cypher} {{name: row.child_name, path: row.path}})
-                            MATCH (parent:{parent_cypher} {{name: row.parent_name, path: row.resolved_parent_file_path}})
-                            MERGE (child)-[r:INHERITS]->(parent)
-                            SET r.confidence_label = coalesce(row.confidence_label, 'EXTRACTED')
-                        """,
-                            batch=internal_batch,
-                        )
+                        session.run(query, batch=chunk)
                     except Exception as e:
+                        # A label absent in this backend fails to bind for the whole
+                        # (child,parent) group; skip it exactly like the old per-pair loop.
                         if _is_binder_exception(e):
-                            continue
+                            return
                         raise e
 
-            for child_label in labels:
-                if child_label not in populated_labels:
-                    continue
+            def _run_external(rows, child_label):
                 child_cypher = _cypher_label(child_label, backend)
-                try:
-                    session.run(
-                        f"""
-                        UNWIND $batch AS row
-                        MATCH (child:{child_cypher} {{name: row.child_name, path: row.path}})
-                        MERGE (parent:ExternalClass {{name: row.parent_name}})
-                        MERGE (child)-[r:INHERITS]->(parent)
-                        SET r.confidence_label = coalesce(row.confidence_label, 'INFERRED')
-                        """,
-                        batch=external_batch,
-                    )
-                except Exception as e:
-                    if _is_binder_exception(e):
-                        continue
-                    raise e
+                query = f"""
+                    UNWIND $batch AS row
+                    MATCH (child:{child_cypher} {{name: row.child_name, path: row.path}})
+                    MERGE (parent:ExternalClass {{name: row.parent_name}})
+                    MERGE (child)-[r:INHERITS]->(parent)
+                    SET r.confidence_label = coalesce(row.confidence_label, 'INFERRED')
+                """
+                for chunk in _chunks(rows):
+                    try:
+                        session.run(query, batch=chunk)
+                    except Exception as e:
+                        if _is_binder_exception(e):
+                            return
+                        raise e
 
+            # Group internal rows by the labels resolution pinned down, so only the
+            # (child_label, parent_label) pairs that actually occur run — instead of a
+            # 12x12 brute force that re-scans the full batch for every combination.
+            #   both labels known   -> one exact query per (child, parent) pair
+            #   child known only    -> enumerate parent labels over just those rows
+            #   neither             -> full 12x12 (rare: ambiguous (name,path) label collision)
+            # Rows never gain a label they wouldn't have matched, and unknown/ambiguous
+            # cases fall back to enumeration, so the produced edge set is unchanged.
+            pair_groups: Dict[tuple, List[Dict[str, Any]]] = {}
+            child_only_groups: Dict[str, List[Dict[str, Any]]] = {}
+            legacy_rows: List[Dict[str, Any]] = []
+            for row in internal_batch:
+                cl = row.get("child_label")
+                pl = row.get("parent_label")
+                if cl and pl:
+                    pair_groups.setdefault((cl, pl), []).append(row)
+                elif cl:
+                    child_only_groups.setdefault(cl, []).append(row)
+                else:
+                    legacy_rows.append(row)
+
+            for (cl, pl), rows in pair_groups.items():
+                _run_internal(rows, cl, pl)
+            for cl, rows in child_only_groups.items():
+                for pl in labels:
+                    if pl not in populated_labels:
+                        continue
+                    _run_internal(rows, cl, pl)
+            if legacy_rows:
+                for cl in labels:
+                    if cl not in populated_labels:
+                        continue
+                    for pl in labels:
+                        if pl not in populated_labels:
+                            continue
+                        _run_internal(legacy_rows, cl, pl)
+
+            # External parents (ExternalClass): group by known child label; fall back to
+            # enumerating child labels for any label-less rows.
+            ext_by_child: Dict[str, List[Dict[str, Any]]] = {}
+            ext_legacy: List[Dict[str, Any]] = []
+            for row in external_batch:
+                cl = row.get("child_label")
+                if cl:
+                    ext_by_child.setdefault(cl, []).append(row)
+                else:
+                    ext_legacy.append(row)
+            for cl, rows in ext_by_child.items():
+                _run_external(rows, cl)
+            if ext_legacy:
+                for cl in labels:
+                    if cl not in populated_labels:
+                        continue
+                    _run_external(ext_legacy, cl)
 
             for file_data in csharp_files:
                 self._create_csharp_inheritance_and_interfaces(session, file_data, imports_map)

{codegraphcontext-0.6.3 → codegraphcontext-0.6.5}/src/codegraphcontext/tools/indexing/resolution/inheritance.py

@@ -6,6 +6,58 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 
+
+# Child construct list -> node label: the 8 kinds that can declare inheritance.
+_INHERIT_KEY_TO_LABEL = {
+    "classes": "Class",
+    "structs": "Struct",
+    "traits": "Trait",
+    "interfaces": "Interface",
+    "mixins": "Mixin",
+    "enums": "Enum",
+    "extensions": "Extension",
+    "variables": "Variable",
+}
+
+# All construct lists whose nodes can be an INHERITS parent, mapped to their label.
+# Matches the 12 labels the writer enumerates. Used to attach exact child/parent
+# labels to rows and to detect the rare (name, path) collisions where more than one
+# node kind shares a name+path — those stay ambiguous so the writer falls back to
+# full enumeration (keeping the produced edge set identical).
+_NODE_KEY_TO_LABEL = {
+    "classes": "Class",
+    "traits": "Trait",
+    "interfaces": "Interface",
+    "structs": "Struct",
+    "enums": "Enum",
+    "unions": "Union",
+    "records": "Record",
+    "mixins": "Mixin",
+    "extensions": "Extension",
+    "modules": "Module",
+    "objects": "Object",
+    "variables": "Variable",
+}
+
+
+def _build_node_label_index(
+    all_file_data: List[Dict[str, Any]],
+) -> Dict[str, Dict[str, set]]:
+    """Map normalized path -> {name -> set(labels)} across all inheritance-eligible
+    node kinds. A (path, name) with exactly one label lets the writer target that
+    label directly; multiple labels leaves it ambiguous (writer enumerates)."""
+    index: Dict[str, Dict[str, set]] = {}
+    for file_data in all_file_data:
+        fpath = str(Path(file_data["path"]).resolve().as_posix())
+        per_file = index.setdefault(fpath, {})
+        for key, label in _NODE_KEY_TO_LABEL.items():
+            for item in file_data.get(key, []):
+                name = item.get("name")
+                if name:
+                    per_file.setdefault(name, set()).add(label)
+    return index
+
+
 def resolve_inheritance_link(
     class_item: Dict[str, Any],
     base_class_str: str,
@@ -13,6 +65,8 @@ def resolve_inheritance_link(
     local_class_names: set,
     local_imports: dict,
     imports_map: dict,
+    child_label: Optional[str] = None,
+    node_label_index: Optional[Dict[str, Dict[str, set]]] = None,
 ) -> Optional[Dict[str, Any]]:
     """Resolve a single inheritance link. Returns row dict or None."""
     import re
@@ -55,21 +109,41 @@ def resolve_inheritance_link(
             if len(possible_paths) == 1:
                 resolved_path = possible_paths[0]
 
+    # Pin the child label only when this (path, name) is a single node kind. If more
+    # than one kind shares it, leave it off so the writer enumerates (byte-identical).
+    child_lbl = None
+    if child_label:
+        if node_label_index is None:
+            child_lbl = child_label
+        else:
+            present = node_label_index.get(caller_file_path, {}).get(class_item["name"])
+            if present and len(present) == 1 and child_label in present:
+                child_lbl = child_label
+
+    def _with_labels(row: Dict[str, Any], parent_path: str) -> Dict[str, Any]:
+        if child_lbl:
+            row["child_label"] = child_lbl
+        if node_label_index is not None:
+            plabels = node_label_index.get(parent_path, {}).get(target_class_name)
+            if plabels and len(plabels) == 1:
+                row["parent_label"] = next(iter(plabels))
+        return row
+
     if resolved_path:
-        return {
+        return _with_labels({
             "child_name": class_item["name"],
             "path": caller_file_path,
             "parent_name": target_class_name,
             "resolved_parent_file_path": resolved_path,
             "confidence_label": "EXTRACTED",
-        }
-    return {
+        }, resolved_path)
+    return _with_labels({
         "child_name": class_item["name"],
         "path": caller_file_path,
         "parent_name": target_class_name,
         "resolved_parent_file_path": "__external__",
         "confidence_label": "INFERRED",
-    }
+    }, "__external__")
 
 
 
@@ -79,6 +153,7 @@ def build_inheritance_and_csharp_files(
     """Returns (inheritance_batch_rows, csharp_file_data_list)."""
     inheritance_batch: List[Dict[str, Any]] = []
     csharp_files: List[Dict[str, Any]] = []
+    node_label_index = _build_node_label_index(all_file_data)
 
     for file_data in all_file_data:
         if file_data.get("lang") == "c_sharp":
@@ -87,7 +162,7 @@ def build_inheritance_and_csharp_files(
 
         caller_file_path = str(Path(file_data["path"]).resolve().as_posix())
         local_class_names = set()
-        for key in ["classes", "structs", "traits", "interfaces", "mixins", "enums", "extensions", "variables"]:
+        for key in _INHERIT_KEY_TO_LABEL:
             for item in file_data.get(key, []):
                 local_class_names.add(item["name"])
 
@@ -97,7 +172,7 @@ def build_inheritance_and_csharp_files(
             if imp.get("name")
         }
 
-        for key in ["classes", "structs", "traits", "interfaces", "mixins", "enums", "extensions", "variables"]:
+        for key, child_label in _INHERIT_KEY_TO_LABEL.items():
             for class_item in file_data.get(key, []):
                 if not class_item.get("bases"):
                     continue
@@ -109,6 +184,8 @@ def build_inheritance_and_csharp_files(
                         local_class_names,
                         local_imports,
                         imports_map,
+                        child_label=child_label,
+                        node_label_index=node_label_index,
                     )
                     if resolved:
                         inheritance_batch.append(resolved)

{codegraphcontext-0.6.3 → 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.3 → 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,
@@ -308,7 +315,26 @@ class CSharpTreeSitterParser:
                             # Parse base list: ": BaseClass, IInterface1, IInterface2"
                             bases_text = bases_text.strip().lstrip(':').strip()
                             if bases_text:
-                                raw_bases = [b.strip() for b in bases_text.split(',')]
+                                # Split on TOP-LEVEL commas only: a naive split
+                                # shredded multi-arg generics —
+                                # `: Dictionary<string, int>` became two bases,
+                                # 'Dictionary<string' and 'int>', creating
+                                # INHERITS edges to nonexistent types (#1538).
+                                raw_bases = []
+                                depth = 0
+                                current = []
+                                for ch in bases_text:
+                                    if ch in "<([":
+                                        depth += 1
+                                    elif ch in ">)]":
+                                        depth = max(0, depth - 1)
+                                    if ch == "," and depth == 0:
+                                        raw_bases.append("".join(current).strip())
+                                        current = []
+                                    else:
+                                        current.append(ch)
+                                if current:
+                                    raw_bases.append("".join(current).strip())
                                 # records might have base calls like : Person(name, age)
                                 # we want just Person
                                 for rb in raw_bases:
@@ -472,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)
@@ -485,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,