Address PR review feedback

- Guard child_by_field_name('name') against None in get_entity_name
- Fix Path.glob() always-truthy bug in add_dependencies (use any())
- Fix resolve_symbol return type: -> list[Entity] in abstract class and all analyzers
- Remove redundant else branch in resolve_method
- Resolve path in analyze_sources to prevent traversal (path.resolve())
- Add setUp/tearDown to test class for graph cleanup
- Add IMPLEMENTS relationship assertion for ConsoleLogger -> ILogger

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: gkorland

api/analyzers/analyzer.py

@@ -127,7 +127,7 @@ def add_symbols(self, entity: Entity) -> None:
         pass
 
     @abstractmethod
-    def resolve_symbol(self, files: dict[Path, File], lsp: SyncLanguageServer, file_path: Path, path: Path, key: str, symbol: Node) -> Entity:
+    def resolve_symbol(self, files: dict[Path, File], lsp: SyncLanguageServer, file_path: Path, path: Path, key: str, symbol: Node) -> list[Entity]:
         """
         Resolve a symbol to an entity.
 
@@ -138,7 +138,7 @@ def resolve_symbol(self, files: dict[Path, File], lsp: SyncLanguageServer, file_
             symbol (Node): The symbol node.
 
         Returns:
-            Entity: The entity.
+            list[Entity]: The resolved entities.
         """
 
         pass

api/analyzers/csharp/analyzer.py

@@ -26,7 +26,7 @@ def _captures(self, pattern: str, node: Node) -> dict:
     def add_dependencies(self, path: Path, files: list[Path]):
         if Path(f"{path}/temp_deps_cs").is_dir():
             return
-        if Path(f"{path}").glob("*.csproj") or Path(f"{path}").glob("*.sln"):
+        if any(Path(f"{path}").glob("*.csproj")) or any(Path(f"{path}").glob("*.sln")):
             subprocess.run(["dotnet", "restore"], cwd=str(path))
 
     def get_entity_label(self, node: Node) -> str:
@@ -47,7 +47,10 @@ def get_entity_label(self, node: Node) -> str:
     def get_entity_name(self, node: Node) -> str:
         if node.type in ['class_declaration', 'interface_declaration', 'enum_declaration',
                          'struct_declaration', 'method_declaration', 'constructor_declaration']:
-            return node.child_by_field_name('name').text.decode('utf-8')
+            name_node = node.child_by_field_name('name')
+            if name_node is None:
+                return ''
+            return name_node.text.decode('utf-8')
         raise ValueError(f"Unknown entity type: {node.type}")
 
     def get_entity_docstring(self, node: Node) -> Optional[str]:
@@ -114,10 +117,6 @@ def resolve_method(self, files: dict[Path, File], lsp: SyncLanguageServer, file_
             func_node = node.child_by_field_name('function')
             if func_node and func_node.type == 'member_access_expression':
                 func_node = func_node.child_by_field_name('name')
-            elif func_node and func_node.type == 'identifier':
-                pass
-            else:
-                func_node = node.child_by_field_name('function')
             if func_node:
                 node = func_node
         for file, resolved_node in self.resolve(files, lsp, file_path, path, node):
@@ -128,7 +127,7 @@ def resolve_method(self, files: dict[Path, File], lsp: SyncLanguageServer, file_
                 res.append(file.entities[method_dec])
         return res
 
-    def resolve_symbol(self, files: dict[Path, File], lsp: SyncLanguageServer, file_path: Path, path: Path, key: str, symbol: Node) -> Entity:
+    def resolve_symbol(self, files: dict[Path, File], lsp: SyncLanguageServer, file_path: Path, path: Path, key: str, symbol: Node) -> list[Entity]:
         if key in ["implement_interface", "base_class", "extend_interface", "parameters", "return_type"]:
             return self.resolve_type(files, lsp, file_path, path, symbol)
         elif key in ["call"]:

api/analyzers/java/analyzer.py

@@ -125,7 +125,7 @@ def resolve_method(self, files: dict[Path, File], lsp: SyncLanguageServer, file_
                 res.append(file.entities[method_dec])
         return res
 
-    def resolve_symbol(self, files: dict[Path, File], lsp: SyncLanguageServer, file_path: Path, path: Path, key: str, symbol: Node) -> Entity:
+    def resolve_symbol(self, files: dict[Path, File], lsp: SyncLanguageServer, file_path: Path, path: Path, key: str, symbol: Node) -> list[Entity]:
         if key in ["implement_interface", "base_class", "extend_interface", "parameters", "return_type"]:
             return self.resolve_type(files, lsp, file_path, path, symbol)
         elif key in ["call"]:

api/analyzers/python/analyzer.py

@@ -114,7 +114,7 @@ def resolve_method(self, files: dict[Path, File], lsp: SyncLanguageServer, file_
                 res.append(file.entities[method_dec])
         return res
 
-    def resolve_symbol(self, files: dict[Path, File], lsp: SyncLanguageServer, file_path: Path, path: Path, key: str, symbol: Node) -> Entity:
+    def resolve_symbol(self, files: dict[Path, File], lsp: SyncLanguageServer, file_path: Path, path: Path, key: str, symbol: Node) -> list[Entity]:
         if key in ["base_class", "parameters", "return_type"]:
             return self.resolve_type(files, lsp, file_path, path, symbol)
         elif key in ["call"]:

api/analyzers/source_analyzer.py

@@ -173,6 +173,7 @@ def analyze_files(self, files: list[Path], path: Path, graph: Graph) -> None:
         self.second_pass(graph, files, path)
 
     def analyze_sources(self, path: Path, ignore: list[str], graph: Graph) -> None:
+        path = path.resolve()
         files = list(path.rglob("*.java")) + list(path.rglob("*.py")) + list(path.rglob("*.cs"))
         # First pass analysis of the source code
         self.first_pass(path, files, ignore, graph)

tests/test_csharp_analyzer.py

@@ -5,6 +5,12 @@
 
 
 class Test_CSharp_Analyzer(unittest.TestCase):
+    def setUp(self):
+        self.g = Graph("csharp")
+
+    def tearDown(self):
+        self.g.delete()
+
     def test_analyzer(self):
         analyzer = SourceAnalyzer()
 
@@ -19,41 +25,45 @@ def test_analyzer(self):
         path = os.path.join(path, 'csharp')
         path = str(path)
 
-        g = Graph("csharp")
-        analyzer.analyze_local_folder(path, g)
+        analyzer.analyze_local_folder(path, self.g)
 
         # Verify ILogger interface was detected
         q = "MATCH (n:Interface {name: 'ILogger'}) RETURN n LIMIT 1"
-        res = g._query(q).result_set
+        res = self.g._query(q).result_set
         self.assertEqual(len(res), 1)
 
         # Verify ConsoleLogger class was detected
         q = "MATCH (n:Class {name: 'ConsoleLogger'}) RETURN n LIMIT 1"
-        res = g._query(q).result_set
+        res = self.g._query(q).result_set
         self.assertEqual(len(res), 1)
 
         # Verify Task class was detected
         q = "MATCH (n:Class {name: 'Task'}) RETURN n LIMIT 1"
-        res = g._query(q).result_set
+        res = self.g._query(q).result_set
         self.assertEqual(len(res), 1)
 
         # Verify methods were detected
         for method_name in ['Log', 'Execute', 'Abort']:
             q = "MATCH (n {name: $name}) RETURN n LIMIT 1"
-            res = g._query(q, {'name': method_name}).result_set
+            res = self.g._query(q, {'name': method_name}).result_set
             self.assertGreaterEqual(len(res), 1, f"Method {method_name} not found")
 
         # Verify Constructor was detected
         q = "MATCH (n:Constructor {name: 'Task'}) RETURN n LIMIT 1"
-        res = g._query(q).result_set
+        res = self.g._query(q).result_set
         self.assertEqual(len(res), 1)
 
         # Verify DEFINES relationships exist (File -> Class/Interface)
         q = "MATCH (f:File)-[:DEFINES]->(n) RETURN count(n)"
-        res = g._query(q).result_set
+        res = self.g._query(q).result_set
         self.assertGreater(res[0][0], 0)
 
         # Verify class defines methods
         q = "MATCH (c:Class {name: 'Task'})-[:DEFINES]->(m) RETURN count(m)"
-        res = g._query(q).result_set
+        res = self.g._query(q).result_set
         self.assertGreater(res[0][0], 0)
+
+        # Verify ConsoleLogger implements ILogger
+        q = "MATCH (c:Class {name: 'ConsoleLogger'})-[:IMPLEMENTS]->(i:Interface {name: 'ILogger'}) RETURN c, i LIMIT 1"
+        res = self.g._query(q).result_set
+        self.assertEqual(len(res), 1)