tree-sitter-analyzer 1.9.1__py3-none-any.whl → 1.9.3__py3-none-any.whl

tree_sitter_analyzer/languages/python_plugin.py

@@ -69,20 +69,16 @@ class PythonElementExtractor(ElementExtractor):
             "function_definition": self._extract_function_optimized,
         }
 
-        if tree is None or tree.root_node is None:
-            log_debug("Tree or root_node is None, returning empty functions list")
-            return functions
-
-        try:
-            self._traverse_and_extract_iterative(
-                tree.root_node, extractors, functions, "function"
-            )
-        except Exception as e:
-            log_debug(f"Error during function extraction: {e}")
-            # Return empty list on error to handle gracefully
-            return []
+        if tree is not None and tree.root_node is not None:
+            try:
+                self._traverse_and_extract_iterative(
+                    tree.root_node, extractors, functions, "function"
+                )
+                log_debug(f"Extracted {len(functions)} Python functions")
+            except Exception as e:
+                log_debug(f"Error during function extraction: {e}")
+                return []
 
-        log_debug(f"Extracted {len(functions)} Python functions")
         return functions
 
     def extract_classes(
@@ -100,15 +96,16 @@ class PythonElementExtractor(ElementExtractor):
             "class_definition": self._extract_class_optimized,
         }
 
-        if tree is None or tree.root_node is None:
-            log_debug("Tree or root_node is None, returning empty classes list")
-            return classes
-
-        self._traverse_and_extract_iterative(
-            tree.root_node, extractors, classes, "class"
-        )
+        if tree is not None and tree.root_node is not None:
+            try:
+                self._traverse_and_extract_iterative(
+                    tree.root_node, extractors, classes, "class"
+                )
+                log_debug(f"Extracted {len(classes)} Python classes")
+            except Exception as e:
+                log_debug(f"Error during class extraction: {e}")
+                return []
 
-        log_debug(f"Extracted {len(classes)} Python classes")
         return classes
 
     def extract_variables(
@@ -178,7 +175,7 @@ class PythonElementExtractor(ElementExtractor):
 
     def _traverse_and_extract_iterative(
         self,
-        root_node: "tree_sitter.Node",
+        root_node: Optional["tree_sitter.Node"],
         extractors: dict[str, Any],
         results: list[Any],
         element_type: str,
@@ -255,22 +252,23 @@ class PythonElementExtractor(ElementExtractor):
                     except Exception:
                         # Skip nodes that cause extraction errors
                         self._processed_nodes.add(node_id)
-                        continue
 
             # Add children to stack
             if current_node.children:
                 try:
                     # Try to reverse children for proper traversal order
-                    children = reversed(current_node.children)
+                    children_list = list(current_node.children)
+                    children_iter = reversed(children_list)
                 except TypeError:
                     # Fallback for Mock objects or other non-reversible types
                     try:
-                        children = list(current_node.children)
+                        children_list = list(current_node.children)
+                        children_iter = iter(children_list)  # type: ignore
                     except TypeError:
                         # If children is not iterable, skip
-                        children = []
+                        children_iter = iter([])  # type: ignore
 
-                for child in children:
+                for child in children_iter:
                     node_stack.append((child, depth + 1))
 
         log_debug(f"Iterative traversal processed {processed_nodes} nodes")
@@ -314,7 +312,7 @@ class PythonElementExtractor(ElementExtractor):
                 # Ensure column indices are within line bounds
                 start_col = max(0, min(start_point[1], len(line)))
                 end_col = max(start_col, min(end_point[1], len(line)))
-                result = line[start_col:end_col]
+                result: str = line[start_col:end_col]
                 self._node_text_cache[node_id] = result
                 return result
             else:
@@ -498,9 +496,8 @@ class PythonElementExtractor(ElementExtractor):
                             break
                         docstring_lines.append(next_line)
 
-                    # If no closing quote found, return None (malformed docstring)
                     if not found_closing_quote:
-                        self._docstring_cache[target_line] = None
+                        self._docstring_cache[target_line] = ""
                         return None
 
                     # Join preserving formatting and add leading newline for multi-line
@@ -511,7 +508,7 @@ class PythonElementExtractor(ElementExtractor):
                     self._docstring_cache[target_line] = docstring
                     return docstring
 
-            self._docstring_cache[target_line] = None
+            self._docstring_cache[target_line] = ""
             return None
 
         except Exception as e:
@@ -748,7 +745,7 @@ class PythonElementExtractor(ElementExtractor):
                         )
 
                         # Group captures by name
-                        captures_dict = {}
+                        captures_dict: dict[str, list[Any]] = {}
                         for node, capture_name in captures:
                             if capture_name not in captures_dict:
                                 captures_dict[capture_name] = []
@@ -787,7 +784,7 @@ class PythonElementExtractor(ElementExtractor):
         """Manual import extraction for tree-sitter 0.25.x compatibility"""
         imports = []
 
-        def walk_tree(node):
+        def walk_tree(node: "tree_sitter.Node") -> None:
             if node.type in ["import_statement", "import_from_statement"]:
                 try:
                     start_line = node.start_point[0] + 1
@@ -824,9 +821,11 @@ class PythonElementExtractor(ElementExtractor):
 
                     if module_name or imported_names:
                         import_obj = Import(
-                            name=module_name or imported_names[0]
-                            if imported_names
-                            else "unknown",
+                            name=(
+                                module_name or imported_names[0]
+                                if imported_names
+                                else "unknown"
+                            ),
                             start_line=start_line,
                             end_line=end_line,
                             raw_text=raw_text,
@@ -1294,51 +1293,13 @@ class PythonPlugin(LanguagePlugin):
         }
 
     def execute_query_strategy(
-        self, tree: "tree_sitter.Tree", source_code: str, query_key: str
-    ) -> list[dict]:
-        """
-        Execute query strategy for Python language
-
-        Args:
-            tree: Tree-sitter tree object
-            source_code: Source code string
-            query_key: Query key to execute
-
-        Returns:
-            List of query results
-        """
-        # Use the extractor to get elements based on query_key
-        extractor = self.get_extractor()
+        self, query_key: str | None, language: str
+    ) -> str | None:
+        """Execute query strategy for Python language"""
+        queries = self.get_queries()
+        return queries.get(query_key) if query_key else None
 
-        # Map query keys to extraction methods
-        if query_key in ["function", "functions", "method", "methods"]:
-            elements = extractor.extract_functions(tree, source_code)
-        elif query_key in ["class", "classes"]:
-            elements = extractor.extract_classes(tree, source_code)
-        elif query_key in ["variable", "variables"]:
-            elements = extractor.extract_variables(tree, source_code)
-        elif query_key in ["import", "imports", "from_import", "from_imports"]:
-            elements = extractor.extract_imports(tree, source_code)
-        else:
-            # For unknown query keys, return empty list
-            return []
-
-        # Convert elements to query result format
-        results = []
-        for element in elements:
-            result = {
-                "capture_name": query_key,
-                "node_type": self._get_node_type_for_element(element),
-                "start_line": element.start_line,
-                "end_line": element.end_line,
-                "text": element.raw_text,
-                "name": element.name,
-            }
-            results.append(result)
-
-        return results
-
-    def _get_node_type_for_element(self, element) -> str:
+    def _get_node_type_for_element(self, element: Any) -> str:
         """Get appropriate node type for element"""
         from ..models import Class, Function, Import, Variable
 
@@ -1459,8 +1420,9 @@ class PythonPlugin(LanguagePlugin):
             )
 
         try:
-            with open(file_path, encoding="utf-8") as f:
-                source_code = f.read()
+            from ..encoding_utils import read_file_safe
+
+            source_code, _ = read_file_safe(file_path)
 
             parser = tree_sitter.Parser()
             parser.language = language
@@ -1536,9 +1498,9 @@ class PythonPlugin(LanguagePlugin):
 
         try:
             elements.extend(extractor.extract_functions(tree, source_code))
-            elements.extend(extractor.extract_classes(tree, source_code))
-            elements.extend(extractor.extract_variables(tree, source_code))
-            elements.extend(extractor.extract_imports(tree, source_code))
+            elements.extend(extractor.extract_classes(tree, source_code))  # type: ignore
+            elements.extend(extractor.extract_variables(tree, source_code))  # type: ignore
+            elements.extend(extractor.extract_imports(tree, source_code))  # type: ignore
         except Exception as e:
             log_error(f"Failed to extract elements: {e}")
 

tree_sitter_analyzer/languages/typescript_plugin.py

@@ -189,7 +189,7 @@ class TypeScriptElementExtractor(ElementExtractor):
 
     def _traverse_and_extract_iterative(
         self,
-        root_node: "tree_sitter.Node",
+        root_node: Optional["tree_sitter.Node"],
         extractors: dict[str, Any],
         results: list[Any],
         element_type: str,
@@ -303,7 +303,7 @@ class TypeScriptElementExtractor(ElementExtractor):
 
                 if start_point[0] == end_point[0]:
                     line = self.content_lines[start_point[0]]
-                    return line[start_point[1] : end_point[1]]
+                    return str(line[start_point[1] : end_point[1]])
                 else:
                     lines = []
                     for i in range(start_point[0], end_point[0] + 1):
@@ -335,6 +335,10 @@ class TypeScriptElementExtractor(ElementExtractor):
                 function_info
             )
 
+            # Skip if no name found
+            if name is None:
+                return None
+
             # Extract TSDoc
             tsdoc = self._extract_tsdoc_for_line(start_line)
 
@@ -461,6 +465,10 @@ class TypeScriptElementExtractor(ElementExtractor):
                 generics,
             ) = method_info
 
+            # Skip if no name found
+            if name is None:
+                return None
+
             # Extract TSDoc
             tsdoc = self._extract_tsdoc_for_line(start_line)
 
@@ -519,6 +527,10 @@ class TypeScriptElementExtractor(ElementExtractor):
                 generics,
             ) = method_info
 
+            # Skip if no name found
+            if name is None:
+                return None
+
             # Extract TSDoc
             tsdoc = self._extract_tsdoc_for_line(start_line)
 
@@ -540,12 +552,7 @@ class TypeScriptElementExtractor(ElementExtractor):
                 # TypeScript-specific properties
                 is_arrow=False,
                 is_method=True,
-                is_signature=True,
                 framework_type=self.framework_type,
-                visibility=visibility,
-                is_getter=is_getter,
-                is_setter=is_setter,
-                # TypeScript-specific properties handled above
             )
         except Exception as e:
             log_debug(f"Failed to extract method signature info: {e}")
@@ -566,6 +573,10 @@ class TypeScriptElementExtractor(ElementExtractor):
 
             name, parameters, is_async, _, return_type, generics = function_info
 
+            # Skip if no name found
+            if name is None:
+                return None
+
             # Extract TSDoc
             tsdoc = self._extract_tsdoc_for_line(start_line)
 
@@ -995,7 +1006,7 @@ class TypeScriptElementExtractor(ElementExtractor):
 
     def _parse_function_signature_optimized(
         self, node: "tree_sitter.Node"
-    ) -> tuple[str, list[str], bool, bool, str | None, list[str]] | None:
+    ) -> tuple[str | None, list[str], bool, bool, str | None, list[str]] | None:
         """Parse function signature for TypeScript functions"""
         try:
             name = None
@@ -1027,7 +1038,18 @@ class TypeScriptElementExtractor(ElementExtractor):
     def _parse_method_signature_optimized(
         self, node: "tree_sitter.Node"
     ) -> (
-        tuple[str, list[str], bool, bool, bool, bool, bool, str | None, str, list[str]]
+        tuple[
+            str | None,
+            list[str],
+            bool,
+            bool,
+            bool,
+            bool,
+            bool,
+            str | None,
+            str,
+            list[str],
+        ]
         | None
     ):
         """Parse method signature for TypeScript class methods"""
@@ -1261,7 +1283,7 @@ class TypeScriptElementExtractor(ElementExtractor):
         self, import_clause_node: "tree_sitter.Node", import_text: str = ""
     ) -> list[str]:
         """Extract import names from import clause"""
-        names = []
+        names: list[str] = []
 
         try:
             # Handle Mock objects in tests
@@ -1416,11 +1438,14 @@ class TypeScriptElementExtractor(ElementExtractor):
 
         try:
             # Test if _get_node_text_optimized is working (for error handling tests)
-            if hasattr(self, "_get_node_text_optimized"):
+            if (
+                hasattr(self, "_get_node_text_optimized")
+                and tree
+                and hasattr(tree, "root_node")
+                and tree.root_node
+            ):
                 # This will trigger the mocked exception in tests
-                self._get_node_text_optimized(
-                    tree.root_node if tree and hasattr(tree, "root_node") else None
-                )
+                self._get_node_text_optimized(tree.root_node)
 
             # Use regex to find require statements
             require_pattern = r"(?:const|let|var)\s+(\w+)\s*=\s*require\s*\(\s*[\"']([^\"']+)[\"']\s*\)"
@@ -1551,7 +1576,7 @@ class TypeScriptElementExtractor(ElementExtractor):
                             return cleaned
                         current_line -= 1
 
-            self._tsdoc_cache[target_line] = None
+            self._tsdoc_cache[target_line] = ""
             return None
 
         except Exception as e:
@@ -1749,8 +1774,9 @@ class TypeScriptPlugin(LanguagePlugin):
             )
 
         try:
-            with open(file_path, encoding="utf-8") as f:
-                source_code = f.read()
+            from ..encoding_utils import read_file_safe
+
+            source_code, _ = read_file_safe(file_path)
 
             parser = tree_sitter.Parser()
             parser.language = language
@@ -1811,112 +1837,11 @@ class TypeScriptPlugin(LanguagePlugin):
         return all_elements
 
     def execute_query_strategy(
-        self, tree: "tree_sitter.Tree", source_code: str, query_key: str
-    ) -> list[CodeElement]:
-        """Execute TypeScript-specific query strategy based on query_key"""
-        if not tree or not source_code:
-            return []
-
-        # Initialize extractor with source code
-        self._extractor.source_code = source_code
-        self._extractor.content_lines = source_code.split("\n")
-        self._extractor._reset_caches()
-        self._extractor._detect_file_characteristics()
-
-        # Map query_key to appropriate extraction method
-        query_mapping = {
-            # Function-related queries
-            "function": lambda: self._extractor.extract_functions(tree, source_code),
-            "async_function": lambda: [
-                f
-                for f in self._extractor.extract_functions(tree, source_code)
-                if getattr(f, "is_async", False)
-            ],
-            "arrow_function": lambda: [
-                f
-                for f in self._extractor.extract_functions(tree, source_code)
-                if getattr(f, "is_arrow", False)
-            ],
-            "method": lambda: [
-                f
-                for f in self._extractor.extract_functions(tree, source_code)
-                if getattr(f, "is_method", False)
-            ],
-            "constructor": lambda: [
-                f
-                for f in self._extractor.extract_functions(tree, source_code)
-                if getattr(f, "is_constructor", False)
-            ],
-            "signature": lambda: [
-                f
-                for f in self._extractor.extract_functions(tree, source_code)
-                if getattr(f, "is_signature", False)
-            ],
-            # Class-related queries
-            "class": lambda: self._extractor.extract_classes(tree, source_code),
-            "interface": lambda: [
-                c
-                for c in self._extractor.extract_classes(tree, source_code)
-                if getattr(c, "class_type", "") == "interface"
-            ],
-            "type_alias": lambda: [
-                c
-                for c in self._extractor.extract_classes(tree, source_code)
-                if getattr(c, "class_type", "") == "type"
-            ],
-            "enum": lambda: [
-                c
-                for c in self._extractor.extract_classes(tree, source_code)
-                if getattr(c, "class_type", "") == "enum"
-            ],
-            # Variable-related queries
-            "variable": lambda: self._extractor.extract_variables(tree, source_code),
-            # Import/Export queries
-            "import": lambda: self._extractor.extract_imports(tree, source_code),
-            "export": lambda: [
-                i
-                for i in self._extractor.extract_imports(tree, source_code)
-                if "export" in getattr(i, "raw_text", "")
-            ],
-            # TypeScript-specific queries
-            "generic": lambda: [
-                c
-                for c in self._extractor.extract_classes(tree, source_code)
-                if "generics" in getattr(c, "raw_text", "")
-            ],
-            "decorator": lambda: [
-                f
-                for f in self._extractor.extract_functions(tree, source_code)
-                if "@" in getattr(f, "raw_text", "")
-            ],
-            # Framework-specific queries
-            "react_component": lambda: [
-                c
-                for c in self._extractor.extract_classes(tree, source_code)
-                if getattr(c, "is_react_component", False)
-            ],
-            "angular_component": lambda: [
-                c
-                for c in self._extractor.extract_classes(tree, source_code)
-                if getattr(c, "framework_type", "") == "angular"
-            ],
-            "vue_component": lambda: [
-                c
-                for c in self._extractor.extract_classes(tree, source_code)
-                if getattr(c, "framework_type", "") == "vue"
-            ],
-        }
-
-        # Execute the appropriate extraction method
-        if query_key in query_mapping:
-            try:
-                return query_mapping[query_key]()
-            except Exception as e:
-                log_error(f"Error executing TypeScript query '{query_key}': {e}")
-                return []
-        else:
-            log_warning(f"Unsupported TypeScript query key: {query_key}")
-            return []
+        self, query_key: str | None, language: str
+    ) -> str | None:
+        """Execute query strategy for TypeScript language"""
+        queries = self.get_queries()
+        return queries.get(query_key) if query_key else None
 
     def get_element_categories(self) -> dict[str, list[str]]:
         """Get TypeScript element categories mapping query_key to node_types"""

tree_sitter_analyzer/mcp/resources/project_stats_resource.py

@@ -214,9 +214,11 @@ class ProjectStatsResource:
             if file_path.is_file() and self._is_supported_code_file(file_path):
                 total_files += 1
                 try:
-                    with open(file_path, encoding="utf-8") as f:
-                        file_lines = sum(1 for _ in f)
-                        total_lines += file_lines
+                    from ...encoding_utils import read_file_safe
+
+                    content, _ = read_file_safe(file_path)
+                    file_lines = len(content.splitlines())
+                    total_lines += file_lines
                 except Exception as e:
                     logger.debug(
                         f"Skipping unreadable file during overview scan: {file_path} ({e})"
@@ -280,9 +282,11 @@ class ProjectStatsResource:
             if file_path.is_file() and self._is_supported_code_file(file_path):
                 total_files += 1
                 try:
-                    with open(file_path, encoding="utf-8") as f:
-                        file_lines = sum(1 for _ in f)
-                        total_lines += file_lines
+                    from ...encoding_utils import read_file_safe
+
+                    content, _ = read_file_safe(file_path)
+                    file_lines = len(content.splitlines())
+                    total_lines += file_lines
                 except Exception as e:
                     logger.debug(f"Failed to count lines for {file_path}: {e}")
                     file_lines = 0
@@ -452,8 +456,10 @@ class ProjectStatsResource:
 
                     # Count lines
                     try:
-                        with open(file_path, encoding="utf-8") as f:
-                            line_count = sum(1 for _ in f)
+                        from ...encoding_utils import read_file_safe
+
+                        content, _ = read_file_safe(file_path)
+                        line_count = len(content.splitlines())
                     except Exception:
                         line_count = 0