fix: address review feedback for JavaScript analyzer

- Fix pyproject.toml: align indentation and add upper bound (<0.24.0) for tree-sitter-javascript
- Remove unused variables (heritage, superclass_node) in add_symbols
- Switch from query.captures() to self._captures() for correct QueryCursor usage
- Filter out node_modules when rglob'ing for *.js files in analyze_sources
- Add unit tests (tests/test_javascript_analyzer.py) and fixture (tests/source_files/javascript/sample.js)

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

Author: gkorland

api/analyzers/javascript/analyzer.py

@@ -49,24 +49,18 @@ def get_entity_types(self) -> list[str]:
 
     def add_symbols(self, entity: Entity) -> None:
         if entity.node.type == 'class_declaration':
-            heritage = entity.node.child_by_field_name('body')
-            if heritage is None:
-                return
-            superclass_node = entity.node.child_by_field_name('name')
             # Check for `extends` clause via class_heritage
             for child in entity.node.children:
                 if child.type == 'class_heritage':
                     for heritage_child in child.children:
                         if heritage_child.type == 'identifier':
                             entity.add_symbol("base_class", heritage_child)
         elif entity.node.type in ['function_declaration', 'method_definition']:
-            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)
-            query = self.language.query("(formal_parameters (identifier) @parameter)")
-            captures = query.captures(entity.node)
+            captures = self._captures("(formal_parameters (identifier) @parameter)", entity.node)
             if 'parameter' in captures:
                 for parameter in captures['parameter']:
                     entity.add_symbol("parameters", parameter)

api/analyzers/source_analyzer.py

@@ -177,7 +177,7 @@ def analyze_files(self, files: list[Path], path: Path, graph: Graph) -> None:
 
     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")) + list(path.rglob("*.js"))
+        files = list(path.rglob("*.java")) + list(path.rglob("*.py")) + list(path.rglob("*.cs")) + [f for f in path.rglob("*.js") if "node_modules" not in f.parts]
         # First pass analysis of the source code
         self.first_pass(path, files, ignore, graph)
 

pyproject.toml

@@ -13,7 +13,7 @@ dependencies = [
     "tree-sitter-c>=0.24.1,<0.25.0",
     "tree-sitter-python>=0.25.0,<0.26.0",
     "tree-sitter-java>=0.23.5,<0.24.0",
-"tree-sitter-javascript>=0.23.0",
+    "tree-sitter-javascript>=0.23.0,<0.24.0",
     "tree-sitter-c-sharp>=0.23.1,<0.24.0",
     "fastapi>=0.115.0,<1.0.0",
     "uvicorn[standard]>=0.34.0,<1.0.0",

tests/source_files/javascript/sample.js

@@ -0,0 +1,31 @@
+/**
+ * Base class for shapes
+ */
+class Shape {
+    constructor(name) {
+        this.name = name;
+    }
+
+    area() {
+        return 0;
+    }
+}
+
+class Circle extends Shape {
+    constructor(radius) {
+        super(radius);
+        this.radius = radius;
+    }
+
+    area() {
+        return Math.PI * this.radius * this.radius;
+    }
+}
+
+function calculateTotal(shapes) {
+    let total = 0;
+    for (const shape of shapes) {
+        total += shape.area();
+    }
+    return total;
+}

tests/test_javascript_analyzer.py

@@ -0,0 +1,102 @@
+"""Tests for the JavaScript analyzer - extraction only (no DB required)."""
+
+import unittest
+from pathlib import Path
+
+from api.analyzers.javascript.analyzer import JavaScriptAnalyzer
+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 TestJavaScriptAnalyzer(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.analyzer = JavaScriptAnalyzer()
+        source_dir = Path(__file__).parent / "source_files" / "javascript"
+        cls.sample_path = source_dir / "sample.js"
+        source = cls.sample_path.read_bytes()
+        tree = cls.analyzer.parser.parse(source)
+        cls.file = File(cls.sample_path, tree)
+
+        # Walk AST and extract entities (mirrors create_hierarchy without Graph)
+        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)
+                # Also recurse into entity children (e.g., class body methods)
+                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_discovers_js_files(self):
+        """SourceAnalyzer should enumerate .js files."""
+        source_dir = Path(__file__).parent / "source_files" / "javascript"
+        js_files = list(source_dir.rglob("*.js"))
+        self.assertTrue(len(js_files) > 0, "Should find .js files")
+
+    def test_entity_types(self):
+        """Analyzer should recognise JS entity types."""
+        self.assertEqual(
+            self.analyzer.get_entity_types(),
+            ['function_declaration', 'class_declaration', 'method_definition'],
+        )
+
+    def test_class_extraction(self):
+        """Classes should be extracted from sample.js."""
+        names = self._entity_names()
+        self.assertIn("Shape", names)
+        self.assertIn("Circle", names)
+
+    def test_function_extraction(self):
+        """Top-level functions should be extracted."""
+        names = self._entity_names()
+        self.assertIn("calculateTotal", names)
+
+    def test_method_extraction(self):
+        """Class methods should be extracted."""
+        names = self._entity_names()
+        self.assertIn("area", names)
+        self.assertIn("constructor", names)
+
+    def test_class_labels(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_function_label(self):
+        """Functions should get the 'Function' label."""
+        for entity in self.file.entities.values():
+            if _entity_name(self.analyzer, entity) == "calculateTotal":
+                self.assertEqual(self.analyzer.get_entity_label(entity.node), "Function")
+
+    def test_base_class_symbol(self):
+        """Circle should have Shape as a base_class symbol."""
+        for entity in self.file.entities.values():
+            if _entity_name(self.analyzer, entity) == "Circle":
+                base_names = [
+                    s.symbol.text.decode("utf-8")
+                    for s in entity.symbols.get("base_class", [])
+                ]
+                self.assertIn("Shape", base_names)
+
+    def test_is_dependency(self):
+        """node_modules paths should be flagged as dependencies."""
+        self.assertTrue(self.analyzer.is_dependency("foo/node_modules/bar/index.js"))
+        self.assertFalse(self.analyzer.is_dependency("src/utils.js"))
+
+
+if __name__ == "__main__":
+    unittest.main()