tree-sitter-analyzer 1.9.2__py3-none-any.whl → 1.9.4__py3-none-any.whl

tree_sitter_analyzer/__init__.py

@@ -11,7 +11,7 @@ Architecture:
 - Data Models: Generic and language-specific code element representations
 """
 
-__version__ = "1.9.2"
+__version__ = "1.9.4"
 __author__ = "aisheng.yu"
 __email__ = "aimasteracc@gmail.com"
 

tree_sitter_analyzer/api.py

@@ -64,7 +64,7 @@ def analyze_file(
         engine = get_engine()
 
         # Perform the analysis
-        analysis_result = engine.analyze_file(file_path, language)
+        analysis_result = engine.analyze_file(file_path, language, queries=queries)
 
         # Convert AnalysisResult to expected API format (same as analyze_code)
         result = {
@@ -85,7 +85,8 @@ def analyze_file(
 
         # Add elements if requested and available
         if include_elements and hasattr(analysis_result, "elements"):
-            result["elements"] = []
+            elements_list: list[dict[str, Any]] = []
+            result["elements"] = elements_list
             for elem in analysis_result.elements:
                 elem_dict = {
                     "name": elem.name,
@@ -145,7 +146,7 @@ def analyze_file(
                     else:
                         elem_dict["class_name"] = None
 
-                result["elements"].append(elem_dict)
+                elements_list.append(elem_dict)
 
         # Add query results if requested and available
         if include_queries and hasattr(analysis_result, "query_results"):
@@ -219,7 +220,8 @@ def analyze_code(
 
         # Add elements if requested and available
         if include_elements and hasattr(analysis_result, "elements"):
-            result["elements"] = []
+            elements_list: list[dict[str, Any]] = []
+            result["elements"] = elements_list
             for elem in analysis_result.elements:
                 elem_dict = {
                     "name": elem.name,
@@ -279,7 +281,7 @@ def analyze_code(
                     else:
                         elem_dict["class_name"] = None
 
-                result["elements"].append(elem_dict)
+                elements_list.append(elem_dict)
 
         # Add query results if requested and available
         if include_queries and hasattr(analysis_result, "query_results"):
@@ -454,8 +456,10 @@ def validate_file(file_path: str | Path) -> dict[str, Any]:
 
         # Check if file is readable
         try:
-            with open(file_path, encoding="utf-8") as f:
-                f.read(100)  # Read first 100 chars to test
+            from .encoding_utils import read_file_safe
+
+            # Test file readability by reading it
+            read_file_safe(file_path)
             result["readable"] = True
             result["size"] = file_path.stat().st_size
         except Exception as e:
@@ -518,6 +522,197 @@ def get_framework_info() -> dict[str, Any]:
         return {"name": "tree-sitter-analyzer", "version": __version__, "error": str(e)}
 
 
+def _group_captures_by_main_node(captures: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """
+    Group query captures by their main nodes (e.g., @method, @class, @function).
+    
+    Each group represents one match of the query pattern, with all its sub-captures.
+    For example, a method_with_annotations query returns:
+    - One @method capture (the main node)
+    - One or more @annotation captures
+    - One @name capture
+    These all get grouped together as one "result".
+    
+    Args:
+        captures: Flat list of all captures from the query
+        
+    Returns:
+        List of grouped results, where each result has a 'captures' dict mapping
+        capture names to their data.
+    """
+    if not captures:
+        return []
+    
+    # Identify the main capture type (method, class, function, etc.)
+    # Usually it's the one with the longest text span or appears first
+    main_capture_types = {"method", "class", "function", "interface", "field"}
+    
+    # Group by start position - captures that share the same main node position
+    position_groups: dict[tuple[int, int], list[dict[str, Any]]] = {}
+    
+    for capture in captures:
+        capture_name = capture.get("capture_name", "")
+        
+        # Find the main node position for this capture
+        if capture_name in main_capture_types:
+            # This is a main node, use its position as the key
+            pos_key = (capture.get("start_byte", 0), capture.get("end_byte", 0))
+        else:
+            # This is a sub-capture, we'll need to find its parent later
+            # For now, use its own position
+            pos_key = (capture.get("start_byte", 0), capture.get("end_byte", 0))
+        
+        if pos_key not in position_groups:
+            position_groups[pos_key] = []
+        position_groups[pos_key].append(capture)
+    
+    # Now group captures that belong together
+    # A capture belongs to a main node if it's within the main node's byte range
+    results = []
+    main_nodes = []
+    
+    # First, identify all main nodes
+    for captures_list in position_groups.values():
+        for capture in captures_list:
+            if capture.get("capture_name") in main_capture_types:
+                main_nodes.append(capture)
+    
+    # For each main node, find all sub-captures within its range
+    for main_node in main_nodes:
+        main_start = main_node.get("start_byte", 0)
+        main_end = main_node.get("end_byte", 0)
+        main_name = main_node.get("capture_name", "")
+        
+        # Collect all captures within this main node's range
+        grouped_captures = {main_name: main_node}
+        
+        for captures_list in position_groups.values():
+            for capture in captures_list:
+                capture_start = capture.get("start_byte", 0)
+                capture_end = capture.get("end_byte", 0)
+                capture_name = capture.get("capture_name", "")
+                
+                # Skip the main node itself
+                if capture is main_node:
+                    continue
+                
+                # Check if this capture is within the main node's range
+                if capture_start >= main_start and capture_end <= main_end:
+                    # Group multiple captures of the same name in a list
+                    if capture_name in grouped_captures:
+                        # Convert to list if not already
+                        if not isinstance(grouped_captures[capture_name], list):
+                            grouped_captures[capture_name] = [grouped_captures[capture_name]]
+                        grouped_captures[capture_name].append(capture)
+                    else:
+                        grouped_captures[capture_name] = capture
+        
+        results.append({"captures": grouped_captures})
+    
+    return results
+
+
+def _group_captures_by_main_node(captures: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """
+    Group query captures by their main nodes (e.g., @method, @class, @function).
+    
+    Each group represents one match of the query pattern, with all its sub-captures.
+    For example, a method_with_annotations query returns:
+    - One @method capture (the main node)
+    - One or more @annotation captures
+    - One @name capture
+    These all get grouped together as one "result".
+    
+    Args:
+        captures: Flat list of all captures from the query
+        
+    Returns:
+        List of grouped results, where each result has:
+        - 'captures' dict mapping capture names to their data
+        - Top-level fields from the main node (text, start_line, end_line, etc.)
+    """
+    if not captures:
+        return []
+    
+    # Identify the main capture type (method, class, function, etc.)
+    # Usually it's the one with the longest text span or appears first
+    main_capture_types = {"method", "class", "function", "interface", "field"}
+    
+    # Group by start position - captures that share the same main node position
+    position_groups: dict[tuple[int, int], list[dict[str, Any]]] = {}
+    
+    for capture in captures:
+        capture_name = capture.get("capture_name", "")
+        
+        # Find the main node position for this capture
+        if capture_name in main_capture_types:
+            # This is a main node, use its position as the key
+            pos_key = (capture.get("start_byte", 0), capture.get("end_byte", 0))
+        else:
+            # This is a sub-capture, we'll need to find its parent later
+            # For now, use its own position
+            pos_key = (capture.get("start_byte", 0), capture.get("end_byte", 0))
+        
+        if pos_key not in position_groups:
+            position_groups[pos_key] = []
+        position_groups[pos_key].append(capture)
+    
+    # Now group captures that belong together
+    # A capture belongs to a main node if it's within the main node's byte range
+    results = []
+    main_nodes = []
+    
+    # First, identify all main nodes
+    for captures_list in position_groups.values():
+        for capture in captures_list:
+            if capture.get("capture_name") in main_capture_types:
+                main_nodes.append(capture)
+    
+    # For each main node, find all sub-captures within its range
+    for main_node in main_nodes:
+        main_start = main_node.get("start_byte", 0)
+        main_end = main_node.get("end_byte", 0)
+        main_name = main_node.get("capture_name", "")
+        
+        # Collect all captures within this main node's range
+        grouped_captures = {main_name: main_node}
+        
+        for captures_list in position_groups.values():
+            for capture in captures_list:
+                capture_start = capture.get("start_byte", 0)
+                capture_end = capture.get("end_byte", 0)
+                capture_name = capture.get("capture_name", "")
+                
+                # Skip the main node itself
+                if capture is main_node:
+                    continue
+                
+                # Check if this capture is within the main node's range
+                if capture_start >= main_start and capture_end <= main_end:
+                    # Group multiple captures of the same name in a list
+                    if capture_name in grouped_captures:
+                        # Convert to list if not already
+                        if not isinstance(grouped_captures[capture_name], list):
+                            grouped_captures[capture_name] = [grouped_captures[capture_name]]
+                        grouped_captures[capture_name].append(capture)
+                    else:
+                        grouped_captures[capture_name] = capture
+        
+        # Create result with top-level fields from main node
+        result = {
+            "captures": grouped_captures,
+            "text": main_node.get("text", ""),
+            "start_line": main_node.get("line_number", 0),
+            "end_line": main_node.get("line_number", 0) + main_node.get("text", "").count("\n"),
+            "start_byte": main_start,
+            "end_byte": main_end,
+            "node_type": main_node.get("node_type", ""),
+        }
+        results.append(result)
+    
+    return results
+
+
 def execute_query(
     file_path: str | Path, query_name: str, language: str | None = None
 ) -> dict[str, Any]:
@@ -543,7 +738,20 @@ def execute_query(
         )
 
         if result["success"] and "query_results" in result:
-            query_results = result["query_results"].get(query_name, [])
+            query_result_dict = result["query_results"].get(query_name, {})
+            
+            # Extract the captures list from the query result dictionary
+            if isinstance(query_result_dict, dict) and "captures" in query_result_dict:
+                raw_captures = query_result_dict["captures"]
+            elif isinstance(query_result_dict, list):
+                raw_captures = query_result_dict
+            else:
+                raw_captures = []
+            
+            # Group captures by their main capture (e.g., @method, @class)
+            # This groups related captures together (e.g., method + its annotations + name)
+            query_results = _group_captures_by_main_node(raw_captures)
+            
             return {
                 "success": True,
                 "query_name": query_name,

tree_sitter_analyzer/cli/argument_validator.py

@@ -11,7 +11,7 @@ from typing import Any
 class CLIArgumentValidator:
     """Validator for CLI argument combinations."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialize the validator."""
         pass
 

tree_sitter_analyzer/cli/commands/advanced_command.py

@@ -49,8 +49,9 @@ class AdvancedCommand(BaseCommand):
             Dictionary containing file metrics
         """
         try:
-            with open(file_path, encoding="utf-8") as f:
-                content = f.read()
+            from ...encoding_utils import read_file_safe
+
+            content, _ = read_file_safe(file_path)
 
             lines = content.split("\n")
             total_lines = len(lines)
@@ -111,10 +112,6 @@ class AdvancedCommand(BaseCommand):
                     if "-->" not in stripped:
                         in_multiline_comment = True
                     continue
-                elif in_multiline_comment and "-->" in stripped:
-                    comment_lines += 1
-                    in_multiline_comment = False
-                    continue
 
                 # If not a comment, it's code
                 code_lines += 1

tree_sitter_analyzer/cli/commands/query_command.py

@@ -5,6 +5,8 @@ Query Command
 Handles query execution functionality.
 """
 
+from typing import Any
+
 from ...core.query_service import QueryService
 from ...output_manager import output_data, output_error, output_info, output_json
 from .base_command import BaseCommand
@@ -13,7 +15,7 @@ from .base_command import BaseCommand
 class QueryCommand(BaseCommand):
     """Command for executing queries."""
 
-    def __init__(self, args):
+    def __init__(self, args: Any) -> None:
         """Initialize the query command with QueryService."""
         super().__init__(args)
         self.query_service = QueryService()

tree_sitter_analyzer/cli/commands/table_command.py

@@ -25,7 +25,7 @@ from .base_command import BaseCommand
 class TableCommand(BaseCommand):
     """Command for generating table format output."""
 
-    def __init__(self, args):
+    def __init__(self, args: Any) -> None:
         """Initialize the table command."""
         super().__init__(args)
 
@@ -56,10 +56,10 @@ class TableCommand(BaseCommand):
 
             # Create table formatter
             include_javadoc = getattr(self.args, "include_javadoc", False)
-            formatter = create_table_formatter(
+            table_formatter: Any = create_table_formatter(
                 self.args.table, language, include_javadoc
             )
-            table_output = formatter.format_structure(structure_result)
+            table_output = table_formatter.format_structure(structure_result)
 
             # Output table
             self._output_table(table_output)

tree_sitter_analyzer/constants.py

@@ -5,6 +5,8 @@ Constants for tree-sitter-analyzer
 This module defines constants used throughout the project to ensure consistency.
 """
 
+from typing import Any, cast
+
 # Element types for unified element management system
 ELEMENT_TYPE_CLASS = "class"
 ELEMENT_TYPE_FUNCTION = "function"
@@ -34,7 +36,7 @@ LEGACY_CLASS_MAPPING = {
 }
 
 
-def get_element_type(element) -> str:
+def get_element_type(element: Any) -> str:
     """
     Get the element type from an element object.
 
@@ -45,7 +47,7 @@ def get_element_type(element) -> str:
         Standardized element type string
     """
     if hasattr(element, "element_type"):
-        return element.element_type
+        return cast(str, element.element_type)
 
     if hasattr(element, "__class__") and hasattr(element.__class__, "__name__"):
         class_name = element.__class__.__name__
@@ -54,7 +56,7 @@ def get_element_type(element) -> str:
     return "unknown"
 
 
-def is_element_of_type(element, element_type: str) -> bool:
+def is_element_of_type(element: Any, element_type: str) -> bool:
     """
     Check if an element is of a specific type.
 

tree_sitter_analyzer/core/analysis_engine.py

@@ -218,7 +218,7 @@ class UnifiedAnalysisEngine:
                     instance = super().__new__(cls)
                     cls._instances[instance_key] = instance
                     # Mark as not initialized for this instance
-                    instance._initialized: bool = False
+                    instance._initialized = False
 
         return cls._instances[instance_key]
 

tree_sitter_analyzer/core/cache_service.py

@@ -18,7 +18,7 @@ from dataclasses import dataclass
 from datetime import datetime, timedelta
 from typing import Any
 
-from cachetools import LRUCache, TTLCache
+from cachetools import LRUCache, TTLCache  # type: ignore[import-untyped]
 
 from ..utils import log_debug, log_info
 

tree_sitter_analyzer/core/engine.py

@@ -48,7 +48,7 @@ class AnalysisEngine:
             raise
 
     def analyze_file(
-        self, file_path: str | Path, language: str | None = None
+        self, file_path: str | Path, language: str | None = None, queries: list[str] | None = None
     ) -> AnalysisResult:
         """
         Analyze a source code file.
@@ -56,6 +56,7 @@ class AnalysisEngine:
         Args:
             file_path: Path to the file to analyze
             language: Optional language override
+            queries: List of query names to execute (all available if not specified)
 
         Returns:
             AnalysisResult containing analysis results
@@ -83,7 +84,7 @@ class AnalysisEngine:
                 )
 
             # Perform analysis
-            return self._perform_analysis(parse_result)
+            return self._perform_analysis(parse_result, queries=queries)
 
         except FileNotFoundError:
             raise
@@ -161,12 +162,15 @@ class AnalysisEngine:
             logger.warning(f"Language detection failed for {file_path}: {e}")
             return "unknown"
 
-    def _perform_analysis(self, parse_result: ParseResult) -> AnalysisResult:
+    def _perform_analysis(
+        self, parse_result: ParseResult, queries: list[str] | None = None
+    ) -> AnalysisResult:
         """
         Perform comprehensive analysis on parsed code.
 
         Args:
             parse_result: Result from parsing operation
+            queries: Optional list of query names to execute (default: all queries)
 
         Returns:
             AnalysisResult containing analysis results
@@ -176,7 +180,13 @@ class AnalysisEngine:
             plugin = self._get_language_plugin(parse_result.language)
 
             # Execute queries
-            query_results = self._execute_queries(parse_result.tree, plugin)
+            query_results = self._execute_queries(
+                parse_result.tree,
+                plugin,
+                queries=queries,
+                source_code=parse_result.source_code or "",
+                language_name=parse_result.language,
+            )
 
             # Extract elements
             elements = self._extract_elements(parse_result, plugin)
@@ -227,13 +237,23 @@ class AnalysisEngine:
 
         return None
 
-    def _execute_queries(self, tree: Tree | None, plugin: Any | None) -> dict[str, Any]:
+    def _execute_queries(
+        self,
+        tree: Tree | None,
+        plugin: Any | None,
+        queries: list[str] | None = None,
+        source_code: str = "",
+        language_name: str = "unknown",
+    ) -> dict[str, Any]:
         """
         Execute queries on the parsed tree.
 
         Args:
             tree: Parsed Tree-sitter tree
             plugin: Language plugin
+            queries: Optional list of query names to execute (default: uses plugin queries or ["class", "method", "field"])
+            source_code: Source code for context
+            language_name: Name of the programming language
 
         Returns:
             Dictionary of query results
@@ -242,8 +262,11 @@ class AnalysisEngine:
             return {}
 
         try:
-            # If plugin is available, use its supported queries
-            if plugin and hasattr(plugin, "get_supported_queries"):
+            # Use provided queries or determine from plugin/fallback
+            if queries is not None:
+                query_names = queries
+            elif plugin and hasattr(plugin, "get_supported_queries"):
+                # If plugin is available, use its supported queries
                 query_names = plugin.get_supported_queries()
             else:
                 # Fallback to common queries that exist in the system
@@ -258,11 +281,12 @@ class AnalysisEngine:
             results = {}
             for query_name in query_names:
                 try:
-                    result = self.query_executor.execute_query(
+                    result = self.query_executor.execute_query_with_language_name(
                         tree,
                         language_obj,
                         query_name,
-                        "",  # Source code would be passed here
+                        source_code,
+                        language_name,
                     )
                     results[query_name] = result
                 except Exception as e:
@@ -535,7 +559,7 @@ class AnalysisEngine:
             logger.error(f"Error getting extensions for {language}: {e}")
             return []
 
-    def get_registry_info(self) -> dict:
+    def get_registry_info(self) -> dict[str, Any]:
         """
         Get registry information (compatibility method)
 

tree_sitter_analyzer/core/query.py

@@ -64,7 +64,6 @@ class QueryExecutor:
             # Validate inputs
             if tree is None:
                 return self._create_error_result("Tree is None", query_name=query_name)
-
             if language is None:
                 return self._create_error_result(  # type: ignore[unreachable]
                     "Language is None", query_name=query_name
@@ -140,6 +139,88 @@ class QueryExecutor:
                 f"Unexpected error: {str(e)}", query_name=query_name
             )
 
+    def execute_query_with_language_name(
+        self,
+        tree: Tree | None,
+        language: Language,
+        query_name: str,
+        source_code: str,
+        language_name: str,
+    ) -> dict[str, Any]:
+        """
+        Execute a predefined query by name with explicit language name.
+
+        Args:
+            tree: Tree-sitter tree to query
+            language: Tree-sitter language object
+            query_name: Name of the predefined query
+            source_code: Source code for context
+            language_name: Name of the programming language
+
+        Returns:
+            Dictionary containing query results and metadata
+        """
+        start_time = time.time()
+        self._execution_stats["total_queries"] += 1
+
+        try:
+            # Validate inputs
+            if tree is None:
+                return self._create_error_result("Tree is None", query_name=query_name)
+            if language is None:
+                return self._create_error_result(  # type: ignore[unreachable]
+                    "Language is None", query_name=query_name
+                )
+
+            # Use the provided language name
+            language_name = language_name.strip().lower() if language_name else "unknown"
+
+            query_string = self._query_loader.get_query(language_name, query_name)
+            if query_string is None:
+                return self._create_error_result(
+                    f"Query '{query_name}' not found", query_name=query_name
+                )
+
+            # Create and execute the query using modern API
+            try:
+                captures = TreeSitterQueryCompat.safe_execute_query(
+                    language, query_string, tree.root_node, fallback_result=[]
+                )
+
+                # Process captures
+                try:
+                    processed_captures = self._process_captures(captures, source_code)
+                except Exception as e:
+                    logger.error(f"Error processing captures for {query_name}: {e}")
+                    return self._create_error_result(
+                        f"Capture processing failed: {str(e)}", query_name=query_name
+                    )
+
+                self._execution_stats["successful_queries"] += 1
+                execution_time = time.time() - start_time
+                self._execution_stats["total_execution_time"] += execution_time
+
+                return {
+                    "captures": processed_captures,
+                    "query_name": query_name,
+                    "query_string": query_string,
+                    "execution_time": execution_time,
+                    "success": True,
+                }
+
+            except Exception as e:
+                logger.error(f"Error executing query '{query_name}': {e}")
+                return self._create_error_result(
+                    f"Query execution failed: {str(e)}", query_name=query_name
+                )
+
+        except Exception as e:
+            logger.error(f"Unexpected error in execute_query: {e}")
+            self._execution_stats["failed_queries"] += 1
+            return self._create_error_result(
+                f"Unexpected error: {str(e)}", query_name=query_name
+            )
+
     def execute_query_string(
         self,
         tree: Tree | None,
@@ -166,7 +247,6 @@ class QueryExecutor:
             # Validate inputs
             if tree is None:
                 return self._create_error_result("Tree is None")
-
             if language is None:
                 return self._create_error_result("Language is None")  # type: ignore[unreachable]