codegraphcontext 0.5.6__tar.gz → 0.5.7__tar.gz

{codegraphcontext-0.5.6/src/codegraphcontext.egg-info → codegraphcontext-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.5.6
+Version: 0.5.7
 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
@@ -372,8 +372,8 @@ CodeGraphContext supports multiple graph database backends to suit your environm
 | **Platform** | **All (Windows Native, macOS, Linux)** | **All (Windows Native, macOS, Linux)** | Unix-only (Linux/macOS/WSL) | All Platforms |
 | **Use Case** | Desktop, IDE, Local development | Custom research projects | Specialized Unix development | Enterprise, Massive graphs |
 | **Requirement**| `pip install kuzu` | `pip install ladybug` | `pip install falkordblite` | Neo4j Server / Docker / Nornic Cloud |
-| **Speed** | ⚡ Extremely Fast | ⚡ Fast | 🚀 Scalable |
-| **Persistence**| Yes (to disk) | Yes (to disk) | Yes (to disk) |
+| **Speed** | ⚡ Extremely Fast | ⚡ Fast | 🚀 Scalable | 🌐 Network-dependent |
+| **Persistence**| Yes (to disk) | Yes (to disk) | Yes (to disk) | Yes (server-side) |
 
 ---
 

{codegraphcontext-0.5.6 → codegraphcontext-0.5.7}/README.md

@@ -274,8 +274,8 @@ CodeGraphContext supports multiple graph database backends to suit your environm
 | **Platform** | **All (Windows Native, macOS, Linux)** | **All (Windows Native, macOS, Linux)** | Unix-only (Linux/macOS/WSL) | All Platforms |
 | **Use Case** | Desktop, IDE, Local development | Custom research projects | Specialized Unix development | Enterprise, Massive graphs |
 | **Requirement**| `pip install kuzu` | `pip install ladybug` | `pip install falkordblite` | Neo4j Server / Docker / Nornic Cloud |
-| **Speed** | ⚡ Extremely Fast | ⚡ Fast | 🚀 Scalable |
-| **Persistence**| Yes (to disk) | Yes (to disk) | Yes (to disk) |
+| **Speed** | ⚡ Extremely Fast | ⚡ Fast | 🚀 Scalable | 🌐 Network-dependent |
+| **Persistence**| Yes (to disk) | Yes (to disk) | Yes (to disk) | Yes (server-side) |
 
 ---
 

{codegraphcontext-0.5.6 → codegraphcontext-0.5.7}/pyproject.toml

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

@@ -2830,15 +2830,18 @@ def analyze_complexity(
 
 @analyze_app.command("dead-code")
 def analyze_dead_code(
-    path: Optional[str] = typer.Argument(None, help="Path to analyze (not yet implemented)"),
+    path: Optional[str] = typer.Argument(None, help="Repository path to scope the analysis to"),
     exclude_decorators: Optional[str] = typer.Option(None, "--exclude", "-e", help="Comma-separated decorators to exclude"),
     context: Optional[str] = typer.Option(None, "--context", "-c", help="Specific context to use"),
 ):
     """
-    Find potentially unused functions and classes.
-    
+    Find potentially unused functions.
+
+    Without a path the whole database is scanned, which on a shared graph
+    reports dead code from every indexed repository. Pass a path to scope it.
+
     Example:
-        cgc analyze dead-code
+        cgc analyze dead-code .
         cgc analyze dead-code --exclude route,task,api
     """
     _load_credentials()
@@ -2849,8 +2852,11 @@ def analyze_dead_code(
     
     try:
         exclude_list = exclude_decorators.split(',') if exclude_decorators else []
-        results = code_finder.find_dead_code(exclude_list)
-        
+        # `path` was accepted and then dropped, so running inside one repository
+        # still reported dead code from every repository in the database.
+        repo_path = Path(path).resolve().as_posix() if path else None
+        results = code_finder.find_dead_code(exclude_list, repo_path=repo_path)
+
         unused_funcs = results.get('potentially_unused_functions', [])
         
         if not unused_funcs:

{codegraphcontext-0.5.6 → codegraphcontext-0.5.7}/src/codegraphcontext/tools/code_finder.py

@@ -14,6 +14,22 @@ logger = logging.getLogger(__name__)
 
 _MAX_TRAVERSAL_DEPTH = 20
 
+# Names that are entry points rather than dead code. Matched on the *whole*
+# name, lowercased. This used to be a substring test (`name CONTAINS 'main'`,
+# `toLower(name) CONTAINS 'entry'`), which silently excluded any function whose
+# name merely contained one of them — `domain_check`, `remainder`,
+# `maintain_index`, `entry_count` — so genuinely unused code was never
+# reported and there was no way to tell.
+_ENTRY_POINT_NAMES = (
+    "main",
+    "setup",
+    "run",
+    "application",
+    "entry",
+    "entrypoint",
+)
+_ENTRY_POINT_NAMES_CYPHER = "[" + ", ".join(f"'{n}'" for n in _ENTRY_POINT_NAMES) + "]"
+
 
 def _sanitize_depth(depth, default: int = 3) -> int:
     """Coerce and clamp a traversal depth before interpolating it into Cypher.
@@ -809,19 +825,16 @@ class CodeFinder:
             query = f"""
                 MATCH (func:Function)
                 WHERE func.is_dependency = false {repo_filter} {func_ignore}
-                  AND NOT func.name IN ['main', 'setup', 'run']
+                  AND NOT toLower(func.name) IN {_ENTRY_POINT_NAMES_CYPHER}
                   AND func.name <> '<module>'
                   AND NOT (func.name STARTS WITH '__' AND func.name ENDS WITH '__')
                   AND NOT func.name STARTS WITH '_test'
                   AND NOT func.name STARTS WITH 'test_'
-                  AND NOT func.name CONTAINS 'main'
-                  AND NOT toLower(func.name) CONTAINS 'application'
-                  AND NOT toLower(func.name) CONTAINS 'entry'
-                  AND NOT toLower(func.name) CONTAINS 'entrypoint'
                   {decorator_filter}
                 WITH func
-                OPTIONAL MATCH (caller:Function)-[:CALLS|HEURISTIC_CALLS]->(func)
-                WHERE caller.is_dependency = false {caller_ignore}
+                OPTIONAL MATCH (caller)-[:CALLS|HEURISTIC_CALLS]->(func)
+                WHERE (caller.is_dependency IS NULL OR caller.is_dependency = false)
+                  {caller_ignore}
                 WITH func, count(caller) as caller_count
                 WHERE caller_count = 0
                 OPTIONAL MATCH (file:File)-[:CONTAINS]->(func)
@@ -1211,16 +1224,31 @@ class CodeFinder:
         try:
             if query_type == "find_callers":
                 results = self.who_calls_function(target, context, repo_path=repo_path)
-                # Hoist target_file_path (constant across rows) to the envelope once,
-                # instead of repeating the absolute path in every row (payload slimming).
-                target_file_path = next((r.pop("target_file_path", None) for r in results), None) if results else None
-                for r in results:
-                    r.pop("target_file_path", None)
-                return {
+                # target_file_path is only constant when `context` pinned a single
+                # definition. Without it, who_calls_function matches
+                # Function {name: $function_name} across every file, so rows
+                # legitimately carry different targets — hoisting the first row's
+                # value and stripping the rest reported every caller as calling
+                # whichever definition happened to sort first.
+                #
+                # Hoist only when the rows agree; otherwise leave the field on each
+                # row so the ambiguity is visible to the caller.
+                target_paths = {r.get("target_file_path") for r in results}
+                target_file_path = target_paths.pop() if len(target_paths) == 1 else None
+                if target_file_path is not None:
+                    for r in results:
+                        r.pop("target_file_path", None)
+                envelope = {
                     "query_type": "find_callers", "target": target, "context": context,
                     "target_file_path": target_file_path, "results": results,
                     "summary": f"Found {len(results)} functions that call '{target}'"
                 }
+                if target_file_path is None and len(target_paths) > 1:
+                    envelope["note"] = (
+                        f"'{target}' is defined in {len(target_paths)} files; each result "
+                        "carries its own target_file_path. Pass `context` to disambiguate."
+                    )
+                return envelope
             
             elif query_type == "find_callees":
                 results = self.what_does_function_call(target, context, repo_path=repo_path)
@@ -1272,7 +1300,10 @@ class CodeFinder:
                 }
             
             elif query_type in ["dead_code", "unused", "unreachable"]:
-                results = self.find_dead_code(repo_path=repo_path)
+                # graph_name must be forwarded: find_dead_code defaults it to None and
+                # re-assigns the shared self._active_graph, so omitting it here
+                # silently redirected the query to the default graph.
+                results = self.find_dead_code(repo_path=repo_path, graph_name=graph_name)
                 return {
                     "query_type": "dead_code", "results": results,
                     "summary": f"Found {len(results['potentially_unused_functions'])} potentially unused functions"
@@ -1281,7 +1312,7 @@ class CodeFinder:
             elif query_type == "find_complexity":
                 limit_val = context if context else target
                 limit = int(limit_val) if limit_val and str(limit_val).isdigit() else 10
-                results = self.find_most_complex_functions(limit, repo_path=repo_path)
+                results = self.find_most_complex_functions(limit, repo_path=repo_path, graph_name=graph_name)
                 return {
                     "query_type": "find_complexity", "limit": limit, "results": results,
                     "summary": f"Found the top {len(results)} most complex functions"

{codegraphcontext-0.5.6 → codegraphcontext-0.5.7}/src/codegraphcontext/tools/handlers/analysis_handlers.py

@@ -236,8 +236,8 @@ def find_java_spring_beans(code_finder: CodeFinder, **args) -> Dict[str, Any]:
     query = f"""
         MATCH (c:Class)
         WHERE {where_clause}
-        OPTIONAL MATCH ()-[:INJECTS]->(c)
-        WITH c, count(*) AS injection_count
+        OPTIONAL MATCH ()-[inj:INJECTS]->(c)
+        WITH c, count(inj) AS injection_count
         RETURN c.name AS name, c.spring_stereotype AS stereotype,
                c.path AS file, c.line_number AS line_number, injection_count
         ORDER BY stereotype, name
@@ -296,7 +296,8 @@ def find_datasource_nodes(code_finder: CodeFinder, **args) -> Dict[str, Any]:
         {kp_where}
         OPTIONAL MATCH (kp:RedisKeyPattern)-[:STORED_IN]->(d)
         RETURN d.name AS datasource,
-               collect({{pattern: kp.pattern, key_type: kp.key_type, count: kp.count}}) AS key_patterns
+               [x IN collect(kp) | {{pattern: x.pattern, key_type: x.key_type,
+                                     count: x.count}}] AS key_patterns
     """
 
     try:

{codegraphcontext-0.5.6 → codegraphcontext-0.5.7}/src/codegraphcontext/tools/handlers/indexing_handlers.py

@@ -19,6 +19,25 @@ def add_code_to_graph(graph_builder, job_manager, loop, list_repos_func, **args)
 
     if not path:
         return {"error": "Path is a required argument (repo_path)."}
+
+    # `graph_name` is advertised in this tool's schema but indexing cannot yet
+    # honour it: GraphBuilder binds its GraphWriter to the default driver at
+    # construction, so a named graph would need a per-job writer threaded
+    # through the whole pipeline. Refuse explicitly rather than write to the
+    # default graph and report success — an agent that believed the repository
+    # landed in a named graph would find nothing there later, with no error to
+    # explain it.
+    graph_name = args.get("graph_name")
+    if graph_name:
+        return {
+            "error": (
+                f"Indexing into a named graph is not supported yet, so "
+                f"graph_name={graph_name!r} cannot be honoured. Omit it to index "
+                "into the default graph, or select the graph via the CLI context "
+                "(`cgc context create` / `cgc index --context`)."
+            ),
+            "unsupported_argument": "graph_name",
+        }
     
     try:
         path_obj = Path(path).resolve()

{codegraphcontext-0.5.6 → codegraphcontext-0.5.7}/src/codegraphcontext/tools/handlers/management_handlers.py

@@ -354,15 +354,15 @@ def get_repository_stats(code_finder: CodeFinder, **args) -> Dict[str, Any]:
                     }
                 
                 # 1. Files
-                file_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(f:File) RETURN count(f) as c"
+                file_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(f:File) RETURN count(DISTINCT f) as c"
                 file_count = session.run(file_query, path=repo_path_obj).single()["c"]
                 
                 # 2. Functions
-                func_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(func:Function) RETURN count(func) as c"
+                func_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(func:Function) RETURN count(DISTINCT func) as c"
                 func_count = session.run(func_query, path=repo_path_obj).single()["c"]
                 
                 # 3. Classes
-                class_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(cls:Class) RETURN count(cls) as c"
+                class_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(cls:Class) RETURN count(DISTINCT cls) as c"
                 class_count = session.run(class_query, path=repo_path_obj).single()["c"]
                 
                 # 4. Modules (imported)

{codegraphcontext-0.5.6 → codegraphcontext-0.5.7}/src/codegraphcontext/tools/indexing/scip_pipeline.py

@@ -191,6 +191,14 @@ async def run_scip_index_async(
             cgcignore_path=cgcignore_path,
             supported_extensions=set(parsers_keys),
         )
+        # Recompute total_files now that we know the full set (SCIP-covered +
+        # supplementary), so progress_percentage stays <= 100% throughout.
+        if job_id:
+            new_total = len(files_data) + sum(
+                1 for f in supplementary_files
+                if str(f.resolve()) not in scip_abs_paths
+            )
+            job_manager.update_job(job_id, total_files=new_total)
         minimal_nodes = 0
         for repo_file in supplementary_files:
             abs_str = str(repo_file.resolve())

{codegraphcontext-0.5.6 → codegraphcontext-0.5.7}/src/codegraphcontext/tools/languages/c.py

@@ -6,20 +6,37 @@ from codegraphcontext.utils.debug_log import debug_log, info_logger, error_logge
 from codegraphcontext.utils.tree_sitter_manager import execute_query
 
 C_QUERIES = {
+    # A pointer return type wraps the function declarator from the OUTSIDE:
+    # `char* f()` is
+    #     function_definition > pointer_declarator > function_declarator > identifier
+    # The second alternative below used to nest these the other way round, which
+    # matches nothing, so no function returning `T*` or `T**` was extracted —
+    # and because pre_scan_c shares this query they were invisible as call
+    # targets too.
     "functions": """
         (function_definition
             declarator: (function_declarator
                 declarator: (identifier) @name
             )
         ) @function_node
-        
+
         (function_definition
-            declarator: (function_declarator
-                declarator: (pointer_declarator
+            declarator: (pointer_declarator
+                declarator: (function_declarator
                     declarator: (identifier) @name
                 )
             )
         ) @function_node
+
+        (function_definition
+            declarator: (pointer_declarator
+                declarator: (pointer_declarator
+                    declarator: (function_declarator
+                        declarator: (identifier) @name
+                    )
+                )
+            )
+        ) @function_node
     """,
     "structs": """
         (struct_specifier
@@ -762,15 +779,25 @@ def pre_scan_c(files: list[Path], parser_wrapper) -> dict:
                 declarator: (identifier) @name
             )
         )
-        
+
         (function_definition
-            declarator: (function_declarator
-                declarator: (pointer_declarator
+            declarator: (pointer_declarator
+                declarator: (function_declarator
                     declarator: (identifier) @name
                 )
             )
         )
-        
+
+        (function_definition
+            declarator: (pointer_declarator
+                declarator: (pointer_declarator
+                    declarator: (function_declarator
+                        declarator: (identifier) @name
+                    )
+                )
+            )
+        )
+
         (struct_specifier
             name: (type_identifier) @name
         )

{codegraphcontext-0.5.6 → codegraphcontext-0.5.7}/src/codegraphcontext/tools/languages/cpp.py

@@ -6,6 +6,13 @@ from codegraphcontext.utils.debug_log import debug_log, info_logger, error_logge
 from codegraphcontext.utils.tree_sitter_manager import execute_query
 
 CPP_QUERIES = {
+    # A pointer or reference return type wraps the function declarator from the
+    # OUTSIDE: `char* f()` is
+    #     function_definition > pointer_declarator > function_declarator > identifier
+    # not function_declarator > pointer_declarator. Matching only the unwrapped
+    # shape meant no function returning `T*`, `T&` or `T**` was ever extracted —
+    # accessors, factories and `operator[]` are pervasive in C++, and because
+    # pre_scan_cpp shares this query they were invisible as call targets too.
     "functions": """
         (function_definition
             declarator: (function_declarator
@@ -16,6 +23,44 @@ CPP_QUERIES = {
                 ]
             )
         ) @function_node
+
+        (function_definition
+            declarator: (pointer_declarator
+                declarator: (function_declarator
+                    declarator: [
+                        (identifier) @name
+                        (field_identifier) @name
+                        (qualified_identifier) @qualified_name
+                    ]
+                )
+            )
+        ) @function_node
+
+        (function_definition
+            declarator: (pointer_declarator
+                declarator: (pointer_declarator
+                    declarator: (function_declarator
+                        declarator: [
+                            (identifier) @name
+                            (field_identifier) @name
+                            (qualified_identifier) @qualified_name
+                        ]
+                    )
+                )
+            )
+        ) @function_node
+
+        (function_definition
+            declarator: (reference_declarator
+                (function_declarator
+                    declarator: [
+                        (identifier) @name
+                        (field_identifier) @name
+                        (qualified_identifier) @qualified_name
+                    ]
+                )
+            )
+        ) @function_node
     """,
     "classes": """
         (class_specifier
@@ -651,6 +696,23 @@ def pre_scan_cpp(files: list[Path], parser_wrapper) -> dict:
         (type_definition declarator: (type_identifier) @name)
         (function_definition declarator: (function_declarator declarator: (identifier) @name))
         (function_definition declarator: (function_declarator declarator: (qualified_identifier) @qualified_name))
+
+        ; A pointer/reference return type wraps the function declarator from the
+        ; outside, so these forms need their own alternatives — without them a
+        ; `T* f()` was not registered here either, and so was unresolvable as a
+        ; call target even once it became a node.
+        (function_definition declarator: (pointer_declarator
+            declarator: (function_declarator declarator: (identifier) @name)))
+        (function_definition declarator: (pointer_declarator
+            declarator: (function_declarator declarator: (qualified_identifier) @qualified_name)))
+        (function_definition declarator: (pointer_declarator declarator: (pointer_declarator
+            declarator: (function_declarator declarator: (identifier) @name))))
+        (function_definition declarator: (pointer_declarator declarator: (pointer_declarator
+            declarator: (function_declarator declarator: (qualified_identifier) @qualified_name))))
+        (function_definition declarator: (reference_declarator
+            (function_declarator declarator: (identifier) @name)))
+        (function_definition declarator: (reference_declarator
+            (function_declarator declarator: (qualified_identifier) @qualified_name)))
     """
 
 

{codegraphcontext-0.5.6 → codegraphcontext-0.5.7}/src/codegraphcontext/tools/languages/csharp.py

@@ -6,6 +6,21 @@ from codegraphcontext.utils.debug_log import debug_log, info_logger, error_logge
 from codegraphcontext.utils.tree_sitter_manager import execute_query
 
 CSHARP_QUERIES = {
+    # Fields and locals share a shape: `variable_declaration` carries the type
+    # and holds one `variable_declarator` per name. There was no `variables`
+    # query at all and the key was hardcoded to [], so C# produced no Variable
+    # nodes — and `resolution/calls.py` lost the local-variable declarations it
+    # uses to infer a receiver's type, so `var s = new UserService(); s.Save();`
+    # could not resolve Save to UserService.Save.
+    "variables": """
+        (field_declaration
+            (variable_declaration) @decl
+        ) @field_node
+
+        (local_declaration_statement
+            (variable_declaration) @decl
+        ) @local_node
+    """,
     "functions": """
         (method_declaration
             name: (identifier) @name
@@ -123,6 +138,7 @@ class CSharpTreeSitterParser:
             parsed_enums = []
             parsed_records = []
             parsed_properties = []
+            parsed_variables = []
             parsed_imports = []
             parsed_calls = []
 
@@ -143,6 +159,8 @@ class CSharpTreeSitterParser:
                     parsed_records = self._parse_type_declarations(captures, source_code, path, "Record")
                 elif capture_name == "properties":
                     parsed_properties = self._parse_properties(captures, source_code, path, tree.root_node)
+                elif capture_name == "variables":
+                    parsed_variables = self._parse_variables(captures)
                 elif capture_name == "imports":
                     parsed_imports = self._parse_imports(captures, source_code)
                 elif capture_name == "calls":
@@ -157,7 +175,7 @@ class CSharpTreeSitterParser:
                 "enums": parsed_enums,
                 "records": parsed_records,
                 "properties": parsed_properties,
-                "variables": [],
+                "variables": parsed_variables,
                 "imports": parsed_imports,
                 "function_calls": parsed_calls,
                 "is_dependency": is_dependency,
@@ -359,6 +377,70 @@ class CSharpTreeSitterParser:
 
         return imports
 
+    def _parse_variables(self, captures: list) -> list:
+        """Fields and locals, from `variable_declaration` nodes.
+
+        Both shapes nest identically — `variable_declaration` carries the type
+        and holds one `variable_declarator` per declared name, so
+        `int a = 1, b = 2;` yields two rows sharing a type.
+        """
+        variables = []
+        seen = set()
+        for node, capture_name in captures:
+            if capture_name != "decl":
+                continue
+            type_node = node.child_by_field_name("type")
+            var_type = self._get_node_text(type_node) if type_node is not None else None
+
+            for declarator in node.children:
+                if declarator.type != "variable_declarator":
+                    continue
+                name_node = declarator.child_by_field_name("name")
+                if name_node is None:
+                    name_node = next(
+                        (c for c in declarator.children if c.type == "identifier"), None
+                    )
+                if name_node is None:
+                    continue
+
+                line_number = name_node.start_point[0] + 1
+                name = self._get_node_text(name_node)
+                if (name, line_number) in seen:
+                    continue
+                seen.add((name, line_number))
+
+                # tree-sitter-c-sharp has no `equals_value_clause`: the
+                # initialiser is a direct sibling following the `=` token.
+                value = None
+                seen_equals = False
+                for child in declarator.children:
+                    if child.type == "=":
+                        seen_equals = True
+                        continue
+                    if seen_equals and child.is_named:
+                        value = self._get_node_text(child)
+                        break
+
+                context, _ctx_type, _ctx_line = self._get_parent_context(
+                    declarator, types=("method_declaration", "function_declaration")
+                )
+                class_context, _c_type, _c_line = self._get_parent_context(
+                    declarator,
+                    types=("class_declaration", "struct_declaration", "record_declaration"),
+                )
+
+                variables.append({
+                    "name": name,
+                    "line_number": line_number,
+                    "value": value,
+                    "type": var_type,
+                    "context": context,
+                    "class_context": class_context,
+                    "lang": self.language_name,
+                    "is_dependency": False,
+                })
+        return variables
+
     def _get_parent_context(self, node: Any, types: Tuple[str, ...] = ('class_declaration', 'struct_declaration', 'function_declaration', 'method_declaration')):
         """Find parent context for C# constructs."""
         curr = node.parent

{codegraphcontext-0.5.6 → codegraphcontext-0.5.7}/src/codegraphcontext/tools/languages/javascript.py

@@ -360,13 +360,77 @@ class JavascriptTreeSitterParser:
                     left_child = child.child_by_field_name('left')
                     if left_child and left_child.type == 'identifier':
                         params.append(self._get_node_text(left_child))
-                elif child.type == 'rest_pattern':
+                elif child.type in ('rest_element', 'rest_pattern'):
                     # Rest parameter: ...args
-                    argument = child.child_by_field_name('argument')
-                    if argument and argument.type == 'identifier':
-                        params.append(f"...{self._get_node_text(argument)}")
+                    # Try named field first, then direct identifier child
+                    name_node = (child.child_by_field_name('name') or
+                                 child.child_by_field_name('argument'))
+                    if name_node is None:
+                        name_node = next(
+                            (c for c in child.children if c.type == 'identifier'), None
+                        )
+                    if name_node:
+                        params.append(f"...{self._get_node_text(name_node)}")
+                elif child.type == 'object_pattern':
+                    # Destructured object: {a}, {a: renamed}, {a = 1}
+                    names = self._pattern_binding_names(child)
+                    params.append("{" + ", ".join(names) + "}" if names else "{...}")
+                elif child.type == 'array_pattern':
+                    # Destructured array: [a, b]
+                    names = self._pattern_binding_names(child)
+                    params.append("[" + ", ".join(names) + "]" if names else "[...]")
         return params
 
+    def _pattern_binding_names(self, pattern_node):
+        """Local names a destructuring pattern binds, in source order.
+
+        Recorded rather than collapsed to a placeholder because the binding is
+        what later code refers to — `function Button({label})` is the dominant
+        React idiom, and `label` is the name that appears in the body. One
+        entry is still emitted per *parameter position* so arity, which call
+        resolution matches on, is unchanged.
+        """
+        names = []
+
+        def walk(node):
+            for child in node.named_children:
+                if child.type == 'shorthand_property_identifier_pattern':
+                    # { a }
+                    names.append(self._get_node_text(child))
+                elif child.type == 'pair_pattern':
+                    # { a: local } — the binding is the value, not the key
+                    value = child.child_by_field_name('value')
+                    if value is not None and value.type == 'identifier':
+                        names.append(self._get_node_text(value))
+                    elif value is not None:
+                        walk(value)  # nested destructuring
+                elif child.type == 'object_assignment_pattern':
+                    # { a = 1 }
+                    target = child.child_by_field_name('left') or (
+                        child.named_children[0] if child.named_children else None
+                    )
+                    if target is not None:
+                        if target.type in (
+                            'identifier', 'shorthand_property_identifier_pattern'
+                        ):
+                            names.append(self._get_node_text(target))
+                        else:
+                            walk(target)
+                elif child.type == 'identifier':
+                    # [ a, b ]
+                    names.append(self._get_node_text(child))
+                elif child.type in ('object_pattern', 'array_pattern'):
+                    walk(child)
+                elif child.type in ('rest_element', 'rest_pattern'):
+                    inner = next(
+                        (c for c in child.children if c.type == 'identifier'), None
+                    )
+                    if inner is not None:
+                        names.append(f"...{self._get_node_text(inner)}")
+
+        walk(pattern_node)
+        return names
+
 
     def _get_jsdoc_comment(self, func_node):
         """Extract JSDoc comment preceding the function."""