codegraphcontext 0.5.5__py3-none-any.whl → 0.5.7__py3-none-any.whl

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/tools/advanced_language_query_tool.py

@@ -82,10 +82,12 @@ class Advanced_language_query:
 
         if language not in self.TOOLKITS:
             raise ValueError(f"Unsupported language: {language}")
-        self.toolkit = self.TOOLKITS[language]()
-
-        # Getting the language query
-        cypher_query = self.toolkit.get_cypher_query(label)
+        try:
+            self.toolkit = self.TOOLKITS[language]()
+            # Getting the language query
+            cypher_query = self.toolkit.get_cypher_query(label)
+        except NotImplementedError as exc:
+            return {"error": str(exc), "language": language, "query": query}
         try:
             debug_log(f"Executing Cypher query: {cypher_query}")
             with self.db_manager.get_driver().session() as session:

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/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/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/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/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/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/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/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/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."""

codegraphcontext/tools/languages/ruby.py

@@ -180,14 +180,47 @@ class RubyTreeSitterParser:
             prev_sibling = prev_sibling.prev_sibling
         return None
 
+    # Ruby parameter node types, and the prefix each carries in source. The
+    # bare `identifier` case is a required positional parameter.
+    _PARAM_PREFIXES = {
+        'optional_parameter': '',        # b = 1
+        'keyword_parameter': '',         # key:
+        'splat_parameter': '*',          # *rest
+        'hash_splat_parameter': '**',    # **opts
+        'block_parameter': '&',          # &blk
+    }
+
     def _parse_method_parameters(self, method_node: Any) -> list[str]:
-        """Parse method parameters from a method node."""
+        """Parse method parameters from a method node.
+
+        Parameters live inside a `method_parameters` child, not directly on the
+        method — the only direct `identifier` child is the method's own name,
+        which this used to skip, so every Ruby method reported no parameters at
+        all and no `HAS_PARAMETER` edge was ever created.
+        """
+        params_node = method_node.child_by_field_name('parameters')
+        if params_node is None:
+            params_node = next(
+                (c for c in method_node.children
+                 if c.type in ('method_parameters', 'parameters', 'bare_parameters')),
+                None,
+            )
+        if params_node is None:
+            return []
+
         params = []
-        # Look for parameters in the method node
-        for child in method_node.children:
-            if child.type == 'identifier' and child != method_node.child_by_field_name('name'):
-                # This is likely a parameter
+        for child in params_node.children:
+            if not child.is_named:
+                continue  # punctuation: ( ) ,
+            if child.type == 'identifier':
                 params.append(self._get_node_text(child))
+                continue
+            prefix = self._PARAM_PREFIXES.get(child.type)
+            if prefix is None:
+                continue
+            name_node = next((c for c in child.children if c.type == 'identifier'), None)
+            if name_node is not None:
+                params.append(prefix + self._get_node_text(name_node))
         return params
 
     def parse(self, path: Path, is_dependency: bool = False, index_source: bool = False) -> Dict[str, Any]:
@@ -297,23 +330,26 @@ class RubyTreeSitterParser:
         # Collect all captures first
         all_captures = list(execute_query(self.language, query_str, root_node))
         
-        # Group captures by class node using a different approach
+        # Read each class's own `name` field rather than matching @name captures
+        # to classes by byte range. An outer class always contains an inner
+        # class's name node, so range-matching assigned the inner name to the
+        # outer class (the first container, in document order) and left the
+        # inner entry nameless — where it was then dropped. `class Client`
+        # wrapping `class TimeoutError` yielded exactly one class, named
+        # TimeoutError, carrying Client's line range.
         captures_by_class = {}
         for node, capture_name in all_captures:
-            if capture_name == 'class':
-                captures_by_class[id(node)] = {'node': node, 'name': None}
-        
-        # Now find names for each class
-        for node, capture_name in all_captures:
-            if capture_name == 'name':
-                # Find which class this name belongs to
-                for class_id, class_data in captures_by_class.items():
-                    class_node = class_data['node']
-                    # Check if this name node is within the class node
-                    if (node.start_byte >= class_node.start_byte and 
-                        node.end_byte <= class_node.end_byte):
-                        captures_by_class[class_id]['name'] = self._get_node_text(node)
-                        break
+            if capture_name != 'class':
+                continue
+            name_node = node.child_by_field_name('name')
+            if name_node is None:
+                # tree-sitter-ruby gives the `class` keyword token the same
+                # node type as the definition; only the definition has a name.
+                continue
+            captures_by_class[id(node)] = {
+                'node': node,
+                'name': self._get_node_text(name_node),
+            }
 
         # Build class entries
         for class_data in captures_by_class.values():

codegraphcontext/tools/package_resolver.py

@@ -49,7 +49,15 @@ def _get_python_package_path(package_name: str) -> Optional[str]:
             if _is_stdlib_module(package_name):
                 return str(module_file)
 
-            return str(module_file.parent)
+            # For a flat, single-file package (e.g. six.py, typing_extensions.py),
+            # the parent is site-packages itself.  Returning it would cause
+            # add_package_to_graph to index every installed dependency.
+            # Return the file instead so only the package is indexed.
+            parent = module_file.parent
+            if parent.name in ("site-packages", "dist-packages"):
+                return str(module_file)
+
+            return str(parent)
 
         if spec.submodule_search_locations:
             locations = list(spec.submodule_search_locations)

codegraphcontext/tools/query_tool_languages/java_toolkit.py

@@ -12,15 +12,23 @@ from typing import Any, Dict, List, Optional
 
 
 class JavaToolkit:
-    """Spring-aware Java analysis methods backed by CodeFinder / raw Cypher."""
+    """Spring-aware Java analysis methods backed by CodeFinder / raw Cypher.
 
-    def __init__(self, code_finder: Any):
-        """
-        Args:
-            code_finder: A ``CodeFinder`` instance (or compatible duck-type).
-        """
+    Note: The generic ``advanced_language_query`` path calls this toolkit
+    with no arguments (consistent with all other language toolkits). The
+    Spring-specific MCP tools (``find_java_spring_endpoints`` /
+    ``find_java_spring_beans``) pass a ``code_finder`` via ``_init_with``.
+    """
+
+    def __init__(self) -> None:
+        self._cf: Any = None
+        self._driver: Any = None
+
+    def _init_with(self, code_finder: Any) -> "JavaToolkit":
+        """Initialise with a live CodeFinder for Spring-specific queries."""
         self._cf = code_finder
         self._driver = code_finder.driver
+        return self
 
     # ── Internal helpers ──────────────────────────────────────────────────────
 
@@ -106,8 +114,8 @@ class JavaToolkit:
             f"""
             MATCH (c:Class)
             WHERE {where}
-            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
@@ -249,5 +257,6 @@ class JavaToolkit:
     # Legacy shim — keeps existing callers working
     def get_cypher_query(self, query: str) -> str:
         raise NotImplementedError(
+            "AdvancedLanguageQuery is not implemented yet for Java. "
             "Use find_spring_endpoints(), find_beans_by_stereotype(), etc. instead."
         )

codegraphcontext/tools/report_generator.py

@@ -220,12 +220,25 @@ def _section_cross_module_calls(driver: Any, limit: int = 20, repo_path: Optiona
 
 def _section_dead_code(driver: Any, limit: int = 20, repo_path: Optional[str] = None) -> str:
     """Functions with no incoming CALLS edges (potential dead code)."""
+    # Share the entry-point list with `CodeFinder.find_dead_code` so the report
+    # and the CLI/MCP tool cannot disagree. They previously did, in both
+    # directions: this query had no name exclusions at all (so every dunder and
+    # `test_*` showed up as dead), while `find_dead_code` restricted callers to
+    # `(caller:Function)` and so missed the File-sourced edges that this one
+    # correctly counts.
+    from .code_finder import _ENTRY_POINT_NAMES_CYPHER
+
     rows = _run_cypher(
         driver,
-        """
+        f"""
         MATCH (fn:Function)
         WHERE (fn.is_dependency IS NULL OR fn.is_dependency = false)
           AND ($repo_path IS NULL OR fn.path STARTS WITH $repo_path)
+          AND NOT toLower(fn.name) IN {_ENTRY_POINT_NAMES_CYPHER}
+          AND fn.name <> '<module>'
+          AND NOT (fn.name STARTS WITH '__' AND fn.name ENDS WITH '__')
+          AND NOT fn.name STARTS WITH '_test'
+          AND NOT fn.name STARTS WITH 'test_'
           AND NOT ()-[:CALLS|HEURISTIC_CALLS]->(fn)
         RETURN fn.name AS name, fn.path AS path
         ORDER BY fn.path, fn.name

codegraphcontext/utils/visualize_graph.py

@@ -12,6 +12,7 @@ import json
 import os
 import tempfile
 import webbrowser
+from html import escape as html_escape
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
@@ -55,6 +56,24 @@ def edge_color(rel_type: str) -> str:
     return _EDGE_COLORS.get(rel_type, _EDGE_COLORS["default"])
 
 
+def _json_for_script(data: Any) -> str:
+    """Serialise ``data`` for inlining inside a ``<script>`` element.
+
+    ``json.dumps`` escapes quotes and backslashes but leaves ``<``, ``>`` and
+    ``&`` alone, so a node name or file path containing ``</script>`` closes
+    the element early and the rest of the document is parsed as markup. Those
+    three characters only ever appear inside string literals, so replacing
+    them with their ``\\uXXXX`` form keeps the payload valid JSON and valid
+    JavaScript while making it inert as markup.
+    """
+    return (
+        json.dumps(data, indent=2)
+        .replace("<", "\\u003c")
+        .replace(">", "\\u003e")
+        .replace("&", "\\u0026")
+    )
+
+
 def build_graph_data(
     nodes: List[Dict[str, Any]],
     edges: List[Dict[str, Any]],
@@ -125,14 +144,15 @@ def render_html(
     str
         Complete HTML document as a string.
     """
-    graph_json = json.dumps(graph_data, indent=2)
+    graph_json = _json_for_script(graph_data)
+    safe_title = html_escape(title)
 
     html = f"""<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>{title}</title>
+  <title>{safe_title}</title>
   <style>
     * {{ box-sizing: border-box; margin: 0; padding: 0; }}
     body {{
@@ -198,7 +218,7 @@ def render_html(
 </head>
 <body>
   <div id="header">
-    <h1>🏗 {title}</h1>
+    <h1>🏗 {safe_title}</h1>
     <span id="stats"></span>
   </div>
   <div id="canvas-container">

codegraphcontext/viz/server.py

@@ -96,13 +96,16 @@ def _get_eid(element):
     if isinstance(element, (int, str)):
         return str(element)
     
-    # If element is a dict (like Neo4j returned items or KuzuDB node/rel dicts)
+    # If element is a dict (like Neo4j returned items or KuzuDB/Ladybug node/rel
+    # dicts). KùzuDB spells its internal id field '_id'; LadybugDB spells the
+    # same field '_ID' (uppercase) — confirmed against a live query on each
+    # embedded backend.
     if isinstance(element, dict):
         # KuzuDB _src / _dst are directly {'offset': X, 'table': Y}
         if 'offset' in element and 'table' in element:
             return f"{element.get('table')}_{element.get('offset')}"
-            
-        for key in ['_id', 'id', 'element_id']:
+
+        for key in ['_id', '_ID', 'id', 'element_id']:
             if key in element:
                 val = element[key]
                 if val is not None:
@@ -116,7 +119,7 @@ def _get_eid(element):
     for attr in ['element_id', 'id', '_id']:
         if hasattr(element, attr):
             val = getattr(element, attr)
-            if val is not None: 
+            if val is not None:
                 # KuzuDB objects if any
                 if isinstance(val, dict):
                     return f"{val.get('table', 0)}_{val.get('offset', 0)}"
@@ -124,6 +127,18 @@ def _get_eid(element):
     return str(id(element))
 
 
+def _meta(d: dict, name: str):
+    """Read a KùzuDB/LadybugDB internal dict field regardless of its casing.
+
+    KùzuDB spells these fields lowercase (_label/_src/_dst); LadybugDB spells
+    the same fields uppercase (_LABEL/_SRC/_DST) — confirmed against a live
+    query on each embedded backend. Keying on one casing only silently drops
+    every row on the other backend.
+    """
+    lower = f"_{name}"
+    return d[lower] if lower in d else d.get(f"_{name.upper()}")
+
+
 @app.get("/api/graph")
 async def get_graph(repo_path: Optional[str] = None, cypher_query: Optional[str] = None):
     if not db_manager:
@@ -186,9 +201,10 @@ async def get_graph(repo_path: Optional[str] = None, cypher_query: Optional[str]
                                 # Extract labels
                                 labels = []
                                 if isinstance(node, dict):
-                                    # KuzuDB node label is under '_label'
-                                    if '_label' in node:
-                                        labels = [node['_label']]
+                                    # KuzuDB node label is under '_label' (LadybugDB: '_LABEL')
+                                    meta_label = _meta(node, 'label')
+                                    if meta_label is not None:
+                                        labels = [meta_label]
                                     elif 'label' in node:
                                         labels = [node['label']]
                                 else:
@@ -247,13 +263,17 @@ async def get_graph(repo_path: Optional[str] = None, cypher_query: Optional[str]
                         # FalkorDB / KuzuDB may return rels as dicts OR objects
                         if isinstance(rel, dict):
                             rid = get_eid(rel)
-                            # KuzuDB uses _src and _dst, FalkorDB uses src_node/dest_node
-                            src = rel.get('_src', rel.get('src_node'))
-                            dst = rel.get('_dst', rel.get('dest_node'))
-                            
+                            # KuzuDB uses _src/_dst (LadybugDB: _SRC/_DST), FalkorDB uses src_node/dest_node
+                            src = _meta(rel, 'src')
+                            if src is None:
+                                src = rel.get('src_node')
+                            dst = _meta(rel, 'dst')
+                            if dst is None:
+                                dst = rel.get('dest_node')
+
                             source = get_eid(src) if src is not None else None
                             target = get_eid(dst) if dst is not None else None
-                            rel_type = str(rel.get('_label', rel.get('relation', rel.get('type', 'RELATED')))).upper()
+                            rel_type = str(_meta(rel, 'label') or rel.get('relation', rel.get('type', 'RELATED'))).upper()
                         else:
                             rid = get_eid(rel)
                             start_node = None
@@ -420,8 +440,9 @@ def parse_node(node, nodes_dict):
         
     labels = []
     if isinstance(node, dict):
-        if '_label' in node:
-            labels = [node['_label']]
+        meta_label = _meta(node, 'label')
+        if meta_label is not None:
+            labels = [meta_label]
         elif 'label' in node:
             labels = [node['label']]
     else:
@@ -463,11 +484,15 @@ def parse_node(node, nodes_dict):
 def parse_rel(rel, edges):
     rid = _get_eid(rel)
     if isinstance(rel, dict):
-        src = rel.get('_src', rel.get('src_node'))
-        dst = rel.get('_dst', rel.get('dest_node'))
+        src = _meta(rel, 'src')
+        if src is None:
+            src = rel.get('src_node')
+        dst = _meta(rel, 'dst')
+        if dst is None:
+            dst = rel.get('dest_node')
         source = _get_eid(src) if src is not None else None
         target = _get_eid(dst) if dst is not None else None
-        rel_type = str(rel.get('_label', rel.get('relation', rel.get('type', 'RELATED')))).upper()
+        rel_type = str(_meta(rel, 'label') or rel.get('relation', rel.get('type', 'RELATED'))).upper()
     else:
         start_node = None
         end_node = None
@@ -510,9 +535,16 @@ def parse_element(val, nodes_dict, edges):
         
     type_name = type(val).__name__
     
-    if type_name in ('Node', 'KuzuNode') or (isinstance(val, dict) and ('_label' in val or 'labels' in val) and not any(k in val for k in ('_src', '_dst', 'src_node', 'dest_node'))):
+    is_dict_rel = isinstance(val, dict) and (
+        any(k in val for k in ('_src', '_dst', '_SRC', '_DST', 'src_node', 'dest_node'))
+    )
+    is_dict_node = isinstance(val, dict) and (
+        '_label' in val or '_LABEL' in val or 'labels' in val
+    ) and not is_dict_rel
+
+    if type_name in ('Node', 'KuzuNode') or is_dict_node:
         parse_node(val, nodes_dict)
-    elif type_name in ('Relationship', 'KuzuRelationship') or (isinstance(val, dict) and any(k in val for k in ('_src', '_dst', 'src_node', 'dest_node'))):
+    elif type_name in ('Relationship', 'KuzuRelationship') or is_dict_rel:
         parse_rel(val, edges)
     elif isinstance(val, (list, tuple)):
         for item in val:

{codegraphcontext-0.5.5.dist-info → codegraphcontext-0.5.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.5.5
+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.5.dist-info → codegraphcontext-0.5.7.dist-info}/RECORD

@@ -14,7 +14,7 @@ codegraphcontext/cli/__init__.py,sha256=2vUlnf7H09M9JbS2gS_LmMUBJWAWcGGHkkl4I2Yr
 codegraphcontext/cli/cli_helpers.py,sha256=w7TCwcL5T6XyRPYKzLkBdt0V6O3YEkWlPl_WTBZHWEA,54179
 codegraphcontext/cli/config_manager.py,sha256=wjYT-aYreRfgRxd0Hy_thLSmlgsV2_JRuMVlVlZlEBo,54960
 codegraphcontext/cli/hook_manager.py,sha256=nKr6SiuM6zA3eZv1rZSNPXUyqkha8Ja0VGQ3_145bLE,7615
-codegraphcontext/cli/main.py,sha256=9JL3Y7rA3LnUweRcRKV7HMQmT5FLSBYjOI1qjyvSIuo,140755
+codegraphcontext/cli/main.py,sha256=G5DEaVvLX4rqOrB2YemRz8YvG8Alc0Naot9B_rhwTJ0,141135
 codegraphcontext/cli/project_config.py,sha256=Slae6fIojlcqRbFzRkAMAsglamryLCPrjUFG16e165g,7492
 codegraphcontext/cli/registry_commands.py,sha256=KwLwxKzMWs0tAFd__nPf_gz3kmlPO5b6Zcb_9Qkguf0,18516
 codegraphcontext/cli/setup_macos.py,sha256=0jcxRsQX7_UcfKrFUnc5Yx3m34w0C3w3x5n7KH6ty6g,3743
@@ -38,11 +38,11 @@ codegraphcontext/core/jobs.py,sha256=8D5E8K_t9jTzPGSAeNK05d-7dPq2SeIJA0igSbHit9A
 codegraphcontext/core/simulator.py,sha256=Sb3PpnoMGVDWvqPVSv5dcQqiL3nTvhmLzzLzJ41krkE,24140
 codegraphcontext/core/watcher.py,sha256=nSfkmZueMBHxx8-7zNHScKtaSGfNWrfjWdAe-T0Y2vI,18793
 codegraphcontext/tools/__init__.py,sha256=iqQPEkDlGXO7rAaLNQrS_ZAbLSklBSK-OowpARq0mig,41
-codegraphcontext/tools/advanced_language_query_tool.py,sha256=QXDKcS3Ug6bNjzY3gjjS2zmPC5cEPyrHGJhAqPXTMuo,4025
-codegraphcontext/tools/code_finder.py,sha256=ZjHoOLYeC5Xc8N4VU5APqGiATzk9AB5gX9u9wVl0SEY,72040
+codegraphcontext/tools/advanced_language_query_tool.py,sha256=8pRVMg-Tbp3JrbN31McyTbum91gJPlrjHFCFVJ78coA,4169
+codegraphcontext/tools/code_finder.py,sha256=d8RK2HQVPD4EQ_ZmhSsEhU6AY0NoYPnIjROwZpGEB78,73651
 codegraphcontext/tools/graph_builder.py,sha256=uPHc4q8u7NQ7lSceRm4IwN3nLxgq9C0MvQtkY8HA9CE,57271
-codegraphcontext/tools/package_resolver.py,sha256=d2lkHNguvL_QRihD2bbBN-aMGrXRgsK-8pLWkci3nFk,7366
-codegraphcontext/tools/report_generator.py,sha256=HLCT6sUmYZxouSXsk0vc1ILV-j2jJjer_RXHTV5MskM,15377
+codegraphcontext/tools/package_resolver.py,sha256=j6s4H5VnourUdJ-CkA3kCOc-Vdewnjc-PNDshAPCiaU,7802
+codegraphcontext/tools/report_generator.py,sha256=3tH83_24nm-pWcY_oXUeLB2jYtGGZmkiBb_oyuhS4WM,16114
 codegraphcontext/tools/scip_indexer.py,sha256=8ZHaooZeQgTtO_wRI0VwiMgIQF1QNAg7o6Xx5VGj3BM,39112
 codegraphcontext/tools/scip_pb2.py,sha256=jSMLR7ud4eaKrIkQN-XDWNaFCyUaueafUm9WgOhjqRA,98270
 codegraphcontext/tools/system.py,sha256=RCUraHQOT-M146CwLM3W1GcBHsAvuans1puL9SPakxs,6647
@@ -52,9 +52,9 @@ codegraphcontext/tools/datasources/__init__.py,sha256=EDY0_s7DJPRzJhfmYUz3Pxv0b6
 codegraphcontext/tools/datasources/cassandra_ingester.py,sha256=sgbskSkvE98qtOprgzkbVSEIasZWe4WXOzaCiRR2c_Q,3060
 codegraphcontext/tools/datasources/mysql_ingester.py,sha256=uWstOv7mOEws1pmT8uAsEBkoOGM1FXOWt_2VCE-tZeg,3991
 codegraphcontext/tools/datasources/redis_ingester.py,sha256=mVUKYmr_v6g7wYaavmQscEHGi_CPZrxYLjfkldc6cWE,3788
-codegraphcontext/tools/handlers/analysis_handlers.py,sha256=wasVt3k0fUwNZn6gr3tvD29cJ3IY5Qqk26B7dkE_2XM,14104
-codegraphcontext/tools/handlers/indexing_handlers.py,sha256=EDPZOcT4LwhqYrvytoN_NvpOPxTWprLmsc67h5HXmGg,6472
-codegraphcontext/tools/handlers/management_handlers.py,sha256=D06vHxhtWeRlyzeFmIDcSNw5qrilLW5sO47HsDdrGcI,17392
+codegraphcontext/tools/handlers/analysis_handlers.py,sha256=8pZAcNNw0CFJ4LfuYqcJ-4cnS-X7_4sKWwd6S7EUGos,14155
+codegraphcontext/tools/handlers/indexing_handlers.py,sha256=sKtbP19EX694zs-6rsVkhwihGwSIWaKjm4N41jMXP2M,7437
+codegraphcontext/tools/handlers/management_handlers.py,sha256=19-fCuMuY5oHXQ9O4F1qG4ZsKKsGpSGbxxA1gH4AE-g,17419
 codegraphcontext/tools/handlers/query_handlers.py,sha256=mqI7pfuSRc92ChAS5IGtrkPyhpPeh-dg-ewVnysx5nw,4643
 codegraphcontext/tools/handlers/watcher_handlers.py,sha256=po0NP3WnUqJAiDyZW9pz2g2V-itnazI10cXQJuc1UZ8,3809
 codegraphcontext/tools/indexing/__init__.py,sha256=exCNeB4UYhKhNSoEBNta_EZ51Kdze4iK4e3oWH8B4X8,126
@@ -66,7 +66,7 @@ codegraphcontext/tools/indexing/pre_scan.py,sha256=St7Hc3-NFTMYF39vWneJL6iIRIc78
 codegraphcontext/tools/indexing/sanitize.py,sha256=IaTP7Aztso3SsvjNZMEqJ1iktV4Tl75hXcYnCWBGpLs,1490
 codegraphcontext/tools/indexing/schema.py,sha256=AcHaqxDi9d5nGjZdg5S6mbjhHo98UYPRfcz1ZpvNEy4,9157
 codegraphcontext/tools/indexing/schema_contract.py,sha256=23ok37ASjvOsU8S-sqyRiKIkGhcUxQ8PSErbBmylggU,1815
-codegraphcontext/tools/indexing/scip_pipeline.py,sha256=Eb7VKN13vPOJ_Ag34c1yQ4c41TGvsemjMKFHnSjBuCg,12724
+codegraphcontext/tools/indexing/scip_pipeline.py,sha256=OLbf0rhs1XU4LTQ6B3mS1-ngbPEKIN69o59rw9Pbk_E,13128
 codegraphcontext/tools/indexing/vector_resolver.py,sha256=0D0QClro7nx9Wx6hbbFlOsO4dqgcTrwPMqE0CsJK01o,5477
 codegraphcontext/tools/indexing/persistence/__init__.py,sha256=hFRlNgiYS7uN9X4e4xfP3c1BvcYSxpmq0k_uaDRn2Fg,121
 codegraphcontext/tools/indexing/persistence/utils.py,sha256=OtndHpE_R14mPz5i-Bo9mA7NsoIuYnCNER-oIwxDOYA,2028
@@ -75,9 +75,9 @@ codegraphcontext/tools/indexing/resolution/__init__.py,sha256=BR57mVydpzjOnFSbGb
 codegraphcontext/tools/indexing/resolution/calls.py,sha256=Uamtm8DXJnwlnTkdzYfu6G74MOcEyQ4njasweE7Nydo,130762
 codegraphcontext/tools/indexing/resolution/inheritance.py,sha256=xataBg0Lvgj3Sexgxx434TmwgRpvODaQs5HQYEVxPVs,21192
 codegraphcontext/tools/indexing/resolution/post_resolution.py,sha256=OzmbbmLwIbKb5wm1RodoyvDST3d35A2e35ruDKBQDF4,10859
-codegraphcontext/tools/languages/c.py,sha256=1lmae7RMttJPJRv1YdRNv8jVn2bU35JxFy_JlMARJyo,30601
-codegraphcontext/tools/languages/cpp.py,sha256=_ZeKPu5c7dR5IhGMWJnklcQOD4DbEMSF_PuntdEEmio,28378
-codegraphcontext/tools/languages/csharp.py,sha256=JvHdg-IsXBm7DC5KtxVJyFMWnQw6FnspCDrAoUqe1H0,23988
+codegraphcontext/tools/languages/c.py,sha256=quo2j0PCTlSOJctqqF_5zKeisERvTDyKuPtz_qvFgQA,31618
+codegraphcontext/tools/languages/cpp.py,sha256=41kDYWbuH6hjNAZyCEH9RhZBNCUz8kQyccw3Ppd-efQ,31389
+codegraphcontext/tools/languages/csharp.py,sha256=oiSBmEf96mIU-2u-0OVXyx3QTn1_lOv-XLPc6aujarA,27502
 codegraphcontext/tools/languages/css.py,sha256=aN1Nm8vHmfV0J0jQ-_q5x0YDTOtLV2IW-5lp7WtGG5o,3789
 codegraphcontext/tools/languages/dart.py,sha256=yjqVA6XwoADrZab95p6wva0jT-PAGw_x90LR-cp2BDk,27160
 codegraphcontext/tools/languages/elisp.py,sha256=QVxJq328bR4DsQK8Vs8b9oxthx1Wm_BS1dsCSjD_P8I,22717
@@ -87,7 +87,7 @@ codegraphcontext/tools/languages/gradle.py,sha256=WA1nQTi-JMHv5vLTJ35ECW0dQCb4PE
 codegraphcontext/tools/languages/haskell.py,sha256=YyslUwcanFs00IinFrj7_TJ2IY2Q97NYsG2Y-9qqolU,19888
 codegraphcontext/tools/languages/html.py,sha256=cjzAH55-JYbObGcMiqjuYD6X0Cbs1Kj5ixcZv9BzMns,5595
 codegraphcontext/tools/languages/java.py,sha256=dpyHBGPhL1FaYP_unh-ncRDOlmmA2nBqnkLc1tacYm0,52024
-codegraphcontext/tools/languages/javascript.py,sha256=Pz2HlHx2YxChx6yA76BNZDNHpjEBjshmSmW8bavKUg0,26941
+codegraphcontext/tools/languages/javascript.py,sha256=LR0W2BKZANQaQlNiIshORmJ08IAVVf9Pv1a8-6pILDo,30197
 codegraphcontext/tools/languages/kotlin.py,sha256=8W367uThQzuTqbFzobUnjm_VEGf_jhLox_fmo13wYsc,88644
 codegraphcontext/tools/languages/lua.py,sha256=TxpOxFd47E4hKwkJpO7b_dMvWveYd4Eaqp1n5SnN-zM,16726
 codegraphcontext/tools/languages/maven.py,sha256=yQjrdSRZJPy6tUopZ7x5qYp8Rtbug4PPbBjCdl9FMDY,6393
@@ -95,7 +95,7 @@ codegraphcontext/tools/languages/mybatis.py,sha256=T6mVBCg7_5xOobBIAqZg9oHtZQy7s
 codegraphcontext/tools/languages/perl.py,sha256=vjz65VFoKLsql2gyaT44B3R0sieloQmxO7fHMp8aqLA,12837
 codegraphcontext/tools/languages/php.py,sha256=WwdFmWvBxQX8rsqHFCr8tdrz_W3pWv_COp1Bw-xiGiE,29804
 codegraphcontext/tools/languages/python.py,sha256=6Fd05Hxc-jVRTa6t0wYuk8-yZ-0MdrRW3xo1TOucxEk,32714
-codegraphcontext/tools/languages/ruby.py,sha256=GCU2AOfU8H4nNzunf0F4OU_aLr3GGIWcSJgVhO89up8,23428
+codegraphcontext/tools/languages/ruby.py,sha256=vkSNS6JOmmVKxG9eDPo5rNd6fNACUScrEjGBZbHg8Fc,24961
 codegraphcontext/tools/languages/rust.py,sha256=o_uhEL_a4REPYXqdH4tljucyXMs5ModaMfeT-sanTBc,15560
 codegraphcontext/tools/languages/scala.py,sha256=TmH_DK7baoo7_eMYdu9e7Cqb0ddVpibrhUO5TQD4AsI,23820
 codegraphcontext/tools/languages/sfc_common.py,sha256=BLCqNO8EoLSdxt1u-1XvrkUotgWHJkXts6w1NQXH6XU,8567
@@ -113,7 +113,7 @@ codegraphcontext/tools/query_tool_languages/dart_toolkit.py,sha256=W5ClOZ-KCRFmw
 codegraphcontext/tools/query_tool_languages/elisp_toolkit.py,sha256=fH8T5HKULMSgq8m46kCUi7Ql1lglTH5taQemJLCrKi0,2591
 codegraphcontext/tools/query_tool_languages/go_toolkit.py,sha256=wK-QMk8fBlJjvnvp9nK9hRq-GbcfsdRaY35E65uacME,273
 codegraphcontext/tools/query_tool_languages/haskell_toolkit.py,sha256=3GMwoSAk8X1nK4Yjz8YMhc_m7bStEI7wYOu0tgTkZl4,283
-codegraphcontext/tools/query_tool_languages/java_toolkit.py,sha256=ABruH-CA_rmm6qCjBKVWoVGEwoApWc5LgJoGEqFUSdo,8961
+codegraphcontext/tools/query_tool_languages/java_toolkit.py,sha256=jjHs_lMgMFu8AgOcUvNrWJSdGSKTZuSYRyjzuESWFMo,9423
 codegraphcontext/tools/query_tool_languages/javascript_toolkit.py,sha256=AZNo63prnaETy1BXy1en40brGODIpcrH6GdmSohp5co,289
 codegraphcontext/tools/query_tool_languages/perl_toolkit.py,sha256=vkd9O5YCXIgSbq2dYVvWT4T8BvL66Qo98TRf0kD5w-c,277
 codegraphcontext/tools/query_tool_languages/python_toolkit.py,sha256=wijYvL7g4wevJhrtbk5asLC8oxIlpZ8IxidRi4HChKM,281
@@ -133,8 +133,8 @@ codegraphcontext/utils/path_sandbox.py,sha256=AemD1DHVMA0lj9BpmRkKwJB2OaE0Sewggm
 codegraphcontext/utils/repo_path.py,sha256=BxS3y6RV_WaZhg_WxgJygS4SnQa-Ryth2fsicfnYorY,1121
 codegraphcontext/utils/tool_limits.py,sha256=3d-QnlzxBNocz58VKNhdsta7ZpWThs1AX46_gYXl6pQ,2751
 codegraphcontext/utils/tree_sitter_manager.py,sha256=Xr26xYL1HUP8V1Hk9d7tbS4RUb774f-Stc2DtuE7oN0,13307
-codegraphcontext/utils/visualize_graph.py,sha256=GncCYgDgT2G23lh-DD-qmrMiahilhHOaAGh6Fei1Yvo,13857
-codegraphcontext/viz/server.py,sha256=IBNSCSOua3xJPcOvKltkU8TGxfiUqJJ3_5vCF4hBKB0,30719
+codegraphcontext/utils/visualize_graph.py,sha256=me35VuizqLyveT86XdgavrgnB2B4lG7WqFyiMr5ea1w,14644
+codegraphcontext/viz/server.py,sha256=l2hM6phhYeMn0vAmMz7wtRGdj7LMkg2BsNMOvS1RUfg,31833
 codegraphcontext/viz/dist/cgcIcon.png,sha256=lik7hnqvkqLc5uo9w9Q_YJXtRx7cWPrXqSLttGtW1sg,58703
 codegraphcontext/viz/dist/favicon.ico,sha256=AjhUxD_Eslt5XuSVHIAZ494Fk__rb5GLXR8qm0elfP4,1870
 codegraphcontext/viz/dist/index.html,sha256=uEaFo3uHWD2KojFiyfWRJoS1_t6zrllOnf_siaB0I5U,1946
@@ -173,9 +173,9 @@ codegraphcontext/viz/dist/wasm/tree-sitter-typescript.wasm,sha256=hRVATc7tOOHthq
 codegraphcontext/viz/dist/wasm/tree-sitter.wasm,sha256=CCeVuI_hXktkBD-DW01xYPv5XoAYVRIqzJUJI5te-RY,196763
 codegraphcontext/viz/dist/wasm/web-tree-sitter.js,sha256=DIaCNqRylrT_PBVw8g4ImeSnhP9uXNe_ycOlUiVGPko,153666
 codegraphcontext/viz/dist/wasm/web-tree-sitter.wasm,sha256=CCeVuI_hXktkBD-DW01xYPv5XoAYVRIqzJUJI5te-RY,196763
-codegraphcontext-0.5.5.dist-info/licenses/LICENSE,sha256=rh8M-bJpQYJnw2vtRVgt0t7piMZXh5QzaKeNEI0vqqA,1061
-codegraphcontext-0.5.5.dist-info/METADATA,sha256=g-1RGSS7QULexGiay2b2oPTWrrm8A3XiQYX8QC2D7Eo,32847
-codegraphcontext-0.5.5.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-codegraphcontext-0.5.5.dist-info/entry_points.txt,sha256=LCxWCWMshdvYGoHBPuQZ8C-e4CiNSHCLXofrNSGHkoE,103
-codegraphcontext-0.5.5.dist-info/top_level.txt,sha256=CBgc6LAPZIO5FS0nSYYkylDifHsZTIqw3Gf5UwDxeGI,17
-codegraphcontext-0.5.5.dist-info/RECORD,,
+codegraphcontext-0.5.7.dist-info/licenses/LICENSE,sha256=rh8M-bJpQYJnw2vtRVgt0t7piMZXh5QzaKeNEI0vqqA,1061
+codegraphcontext-0.5.7.dist-info/METADATA,sha256=pb9kZrMtqIxBsrCVhKXy0zX--PZTWRc6jE0Px6G7dyg,32892
+codegraphcontext-0.5.7.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+codegraphcontext-0.5.7.dist-info/entry_points.txt,sha256=LCxWCWMshdvYGoHBPuQZ8C-e4CiNSHCLXofrNSGHkoE,103
+codegraphcontext-0.5.7.dist-info/top_level.txt,sha256=CBgc6LAPZIO5FS0nSYYkylDifHsZTIqw3Gf5UwDxeGI,17
+codegraphcontext-0.5.7.dist-info/RECORD,,