fix: address review feedback for Kotlin analyzer

- Replace wildcard import with explicit Entity and File imports
- Fix tree-sitter queries: Kotlin grammar uses 'identifier' not 'type_identifier'
- Fix get_entity_name: use 'identifier' for all entity types
- Separate superclass/interface in add_symbols: first delegation specifier
  is base_class, rest are implement_interface
- Use self._captures() instead of direct query.captures() calls
- Handle constructor_invocation in delegation specifiers (e.g. Shape(...))
- Fix source_analyzer second_pass: use entity.resolved_symbols instead of
  iterating raw symbol nodes, so graph edges use resolved entity IDs
- Fix resolve_method: use 'identifier' instead of 'simple_identifier'
- Add unit tests and Kotlin fixture (11 tests, all passing)

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

Author: gkorland

api/analyzers/kotlin/analyzer.py

@@ -1,5 +1,6 @@
 from pathlib import Path
-from ...entities import *
+from ...entities.entity import Entity
+from ...entities.file import File
 from typing import Optional
 from ..analyzer import AbstractAnalyzer
 
@@ -38,15 +39,9 @@ def get_entity_label(self, node: Node) -> str:
         raise ValueError(f"Unknown entity type: {node.type}")
 
     def get_entity_name(self, node: Node) -> str:
-        if node.type in ['class_declaration', 'object_declaration']:
-            # Find the type_identifier child
-            for child in node.children:
-                if child.type == 'type_identifier':
-                    return child.text.decode('utf-8')
-        elif node.type == 'function_declaration':
-            # Find the simple_identifier child
+        if node.type in ['class_declaration', 'object_declaration', 'function_declaration']:
             for child in node.children:
-                if child.type == 'simple_identifier':
+                if child.type == 'identifier':
                     return child.text.decode('utf-8')
         raise ValueError(f"Cannot extract name from entity type: {node.type}")
 
@@ -64,52 +59,58 @@ def get_entity_docstring(self, node: Node) -> Optional[str]:
     def get_entity_types(self) -> list[str]:
         return ['class_declaration', 'object_declaration', 'function_declaration']
 
+    def _get_delegation_types(self, entity: Entity) -> list:
+        """Extract type identifiers from delegation specifiers in order."""
+        types = []
+        for child in entity.node.children:
+            if child.type == 'delegation_specifiers':
+                for spec in child.children:
+                    if spec.type == 'delegation_specifier':
+                        for sub in spec.children:
+                            if sub.type == 'constructor_invocation':
+                                for s in sub.children:
+                                    if s.type == 'user_type':
+                                        for id_node in s.children:
+                                            if id_node.type == 'identifier':
+                                                types.append(id_node)
+                            elif sub.type == 'user_type':
+                                for id_node in sub.children:
+                                    if id_node.type == 'identifier':
+                                        types.append(id_node)
+        return types
+
     def add_symbols(self, entity: Entity) -> None:
         if entity.node.type == 'class_declaration':
-            # Find superclass (extends)
-            superclass_query = self.language.query("(delegation_specifier (user_type (type_identifier) @superclass))")
-            superclass_captures = superclass_query.captures(entity.node)
-            if 'superclass' in superclass_captures:
-                for superclass in superclass_captures['superclass']:
-                    entity.add_symbol("base_class", superclass)
-            
-            # Find interfaces (implements)
-            # In Kotlin, both inheritance and interface implementation use the same syntax
-            # We'll treat all as interfaces for now since Kotlin can only extend one class
-            interface_query = self.language.query("(delegation_specifier (user_type (type_identifier) @interface))")
-            interface_captures = interface_query.captures(entity.node)
-            if 'interface' in interface_captures:
-                for interface in interface_captures['interface']:
-                    entity.add_symbol("implement_interface", interface)
+            types = self._get_delegation_types(entity)
+            if types:
+                # First one is the superclass (base_class)
+                entity.add_symbol("base_class", types[0])
+                # Remaining are interfaces
+                for iface in types[1:]:
+                    entity.add_symbol("implement_interface", iface)
 
         elif entity.node.type == 'object_declaration':
-            # Objects can also have delegation specifiers
-            interface_query = self.language.query("(delegation_specifier (user_type (type_identifier) @interface))")
-            interface_captures = interface_query.captures(entity.node)
-            if 'interface' in interface_captures:
-                for interface in interface_captures['interface']:
-                    entity.add_symbol("implement_interface", interface)
+            types = self._get_delegation_types(entity)
+            for t in types:
+                entity.add_symbol("implement_interface", t)
 
         elif entity.node.type == 'function_declaration':
             # Find function calls
-            query = self.language.query("(call_expression) @reference.call")
-            captures = query.captures(entity.node)
+            captures = self._captures("(call_expression) @reference.call", entity.node)
             if 'reference.call' in captures:
                 for caller in captures['reference.call']:
                     entity.add_symbol("call", caller)
 
             # Find parameters with types
-            param_query = self.language.query("(parameter type: (user_type (type_identifier) @parameter))")
-            param_captures = param_query.captures(entity.node)
-            if 'parameter' in param_captures:
-                for parameter in param_captures['parameter']:
+            captures = self._captures("(parameter (user_type (identifier) @parameter))", entity.node)
+            if 'parameter' in captures:
+                for parameter in captures['parameter']:
                     entity.add_symbol("parameters", parameter)
 
             # Find return type
-            return_type_query = self.language.query("(function_declaration type: (user_type (type_identifier) @return_type))")
-            return_type_captures = return_type_query.captures(entity.node)
-            if 'return_type' in return_type_captures:
-                for return_type in return_type_captures['return_type']:
+            captures = self._captures("(function_declaration (user_type (identifier) @return_type))", entity.node)
+            if 'return_type' in captures:
+                for return_type in captures['return_type']:
                     entity.add_symbol("return_type", return_type)
 
     def is_dependency(self, file_path: str) -> bool:
@@ -134,7 +135,7 @@ def resolve_method(self, files: dict[Path, File], lsp: SyncLanguageServer, file_
         if node.type == 'call_expression':
             # Find the identifier being called
             for child in node.children:
-                if child.type in ['simple_identifier', 'navigation_expression']:
+                if child.type in ['identifier', 'navigation_expression']:
                     for file, resolved_node in self.resolve(files, lsp, file_path, path, child):
                         method_dec = self.find_parent(resolved_node, ['function_declaration', 'class_declaration', 'object_declaration'])
                         if method_dec and method_dec.type in ['class_declaration', 'object_declaration']:

api/analyzers/source_analyzer.py

@@ -168,20 +168,20 @@ def second_pass(self, graph: Graph, files: list[Path], path: Path) -> None:
                 logging.info(f'Processing file ({i + 1}/{files_len}): {file_path}')
                 for _, entity in file.entities.items():
                     entity.resolved_symbol(lambda key, symbol, fp=file_path: analyzers[fp.suffix].resolve_symbol(self.files, lsps[fp.suffix], fp, path, key, symbol))
-                    for key, symbols in entity.symbols.items():
-                        for symbol in symbols:
+                    for key, resolved_set in entity.resolved_symbols.items():
+                        for resolved in resolved_set:
                             if key == "base_class":
-                                graph.connect_entities("EXTENDS", entity.id, symbol.id)
+                                graph.connect_entities("EXTENDS", entity.id, resolved.id)
                             elif key == "implement_interface":
-                                graph.connect_entities("IMPLEMENTS", entity.id, symbol.id)
+                                graph.connect_entities("IMPLEMENTS", entity.id, resolved.id)
                             elif key == "extend_interface":
-                                graph.connect_entities("EXTENDS", entity.id, symbol.id)
+                                graph.connect_entities("EXTENDS", entity.id, resolved.id)
                             elif key == "call":
-                                graph.connect_entities("CALLS", entity.id, symbol.id)
+                                graph.connect_entities("CALLS", entity.id, resolved.id)
                             elif key == "return_type":
-                                graph.connect_entities("RETURNS", entity.id, symbol.id)
+                                graph.connect_entities("RETURNS", entity.id, resolved.id)
                             elif key == "parameters":
-                                graph.connect_entities("PARAMETERS", entity.id, symbol.id)
+                                graph.connect_entities("PARAMETERS", entity.id, resolved.id)
 
     def analyze_files(self, files: list[Path], path: Path, graph: Graph) -> None:
         self.first_pass(path, files, [], graph)

tests/source_files/kotlin/sample.kt

@@ -0,0 +1,39 @@
+/**
+ * A base interface for logging
+ */
+interface Logger {
+    fun log(message: String)
+}
+
+/**
+ * Base class for shapes
+ */
+open class Shape(val name: String) {
+    open fun area(): Double = 0.0
+}
+
+class Circle(val radius: Double) : Shape("circle"), Logger {
+    override fun area(): Double {
+        return Math.PI * radius * radius
+    }
+
+    override fun log(message: String) {
+        println(message)
+    }
+}
+
+fun calculateTotal(shapes: List<Shape>): Double {
+    var total = 0.0
+    for (shape in shapes) {
+        total += shape.area()
+    }
+    return total
+}
+
+object AppConfig : Logger {
+    val version = "1.0"
+
+    override fun log(message: String) {
+        println("[$version] $message")
+    }
+}

tests/test_kotlin_analyzer.py

@@ -0,0 +1,116 @@
+"""Tests for the Kotlin analyzer - extraction only (no DB required)."""
+
+import unittest
+from pathlib import Path
+
+from api.analyzers.kotlin.analyzer import KotlinAnalyzer
+from api.entities.entity import Entity
+from api.entities.file import File
+
+
+def _entity_name(analyzer, entity):
+    """Get the name of an entity using the analyzer."""
+    return analyzer.get_entity_name(entity.node)
+
+
+class TestKotlinAnalyzer(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.analyzer = KotlinAnalyzer()
+        source_dir = Path(__file__).parent / "source_files" / "kotlin"
+        cls.sample_path = source_dir / "sample.kt"
+        source = cls.sample_path.read_bytes()
+        tree = cls.analyzer.parser.parse(source)
+        cls.file = File(cls.sample_path, tree)
+
+        # Walk AST and extract entities
+        types = cls.analyzer.get_entity_types()
+        stack = [tree.root_node]
+        while stack:
+            node = stack.pop()
+            if node.type in types:
+                entity = Entity(node)
+                cls.analyzer.add_symbols(entity)
+                cls.file.add_entity(entity)
+                stack.extend(node.children)
+            else:
+                stack.extend(node.children)
+
+    def _entity_names(self):
+        return [_entity_name(self.analyzer, e) for e in self.file.entities.values()]
+
+    def test_entity_types(self):
+        """Analyzer should recognise Kotlin entity types."""
+        self.assertEqual(
+            self.analyzer.get_entity_types(),
+            ['class_declaration', 'object_declaration', 'function_declaration'],
+        )
+
+    def test_class_extraction(self):
+        """Classes should be extracted."""
+        names = self._entity_names()
+        self.assertIn("Shape", names)
+        self.assertIn("Circle", names)
+
+    def test_interface_extraction(self):
+        """Interfaces should be extracted."""
+        names = self._entity_names()
+        self.assertIn("Logger", names)
+
+    def test_object_extraction(self):
+        """Object declarations should be extracted."""
+        names = self._entity_names()
+        self.assertIn("AppConfig", names)
+
+    def test_function_extraction(self):
+        """Top-level functions should be extracted."""
+        names = self._entity_names()
+        self.assertIn("calculateTotal", names)
+
+    def test_class_label(self):
+        """Classes should get the 'Class' label."""
+        for entity in self.file.entities.values():
+            if _entity_name(self.analyzer, entity) in ("Shape", "Circle"):
+                self.assertEqual(self.analyzer.get_entity_label(entity.node), "Class")
+
+    def test_interface_label(self):
+        """Interfaces should get the 'Interface' label."""
+        for entity in self.file.entities.values():
+            if _entity_name(self.analyzer, entity) == "Logger":
+                self.assertEqual(self.analyzer.get_entity_label(entity.node), "Interface")
+
+    def test_object_label(self):
+        """Object declarations should get the 'Object' label."""
+        for entity in self.file.entities.values():
+            if _entity_name(self.analyzer, entity) == "AppConfig":
+                self.assertEqual(self.analyzer.get_entity_label(entity.node), "Object")
+
+    def test_base_class_symbol(self):
+        """Circle should have Shape as base_class (first delegation specifier)."""
+        for entity in self.file.entities.values():
+            if _entity_name(self.analyzer, entity) == "Circle":
+                base_names = [
+                    s.text.decode("utf-8")
+                    for s in entity.symbols.get("base_class", [])
+                ]
+                self.assertIn("Shape", base_names)
+
+    def test_interface_implementation(self):
+        """Circle should implement Logger (second delegation specifier)."""
+        for entity in self.file.entities.values():
+            if _entity_name(self.analyzer, entity) == "Circle":
+                iface_names = [
+                    s.text.decode("utf-8")
+                    for s in entity.symbols.get("implement_interface", [])
+                ]
+                self.assertIn("Logger", iface_names)
+
+    def test_is_dependency(self):
+        """Build/gradle paths should be flagged as dependencies."""
+        self.assertTrue(self.analyzer.is_dependency("project/build/classes/Main.kt"))
+        self.assertTrue(self.analyzer.is_dependency("project/.gradle/cache/lib.kt"))
+        self.assertFalse(self.analyzer.is_dependency("src/main/kotlin/App.kt"))
+
+
+if __name__ == "__main__":
+    unittest.main()