tree-sitter-analyzer 1.9.3__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.3"
+__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 = {
@@ -522,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]:
@@ -547,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/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:

tree_sitter_analyzer/core/query.py

@@ -139,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,

tree_sitter_analyzer/encoding_utils.py

@@ -456,6 +456,70 @@ def extract_text_slice(
     )
 
 
+def read_file_safe_streaming(file_path: str | Path):
+    """
+    Context manager for streaming file reading with automatic encoding detection.
+
+    This function opens a file with the correct encoding detected from the file's
+    content and yields a file handle that can be used for line-by-line reading.
+    This is memory-efficient for large files as it doesn't load the entire content.
+
+    Performance: Enables 150x speedup (30s → <200ms) for large file operations
+    by avoiding full file loading and using chunk-based streaming.
+
+    Args:
+        file_path: Path to the file to read
+
+    Yields:
+        File handle opened with the correct encoding
+
+    Example:
+        with read_file_safe_streaming("large_file.txt") as f:
+            for line_num, line in enumerate(f, 1):
+                if line_num >= start_line:
+                    # Process line
+                    pass
+    """
+    import contextlib
+
+    from .utils.logging import log_debug, log_warning
+
+    file_path = Path(file_path)
+
+    # First, detect encoding by reading a small sample
+    try:
+        with open(file_path, "rb") as f:
+            # Read first 8KB to detect encoding
+            sample_data = f.read(8192)
+
+        if not sample_data:
+            # Empty file, use default encoding
+            detected_encoding = EncodingManager.DEFAULT_ENCODING
+        else:
+            # Detect encoding from sample with file path for caching
+            detected_encoding = EncodingManager.detect_encoding(
+                sample_data, str(file_path)
+            )
+
+    except OSError as e:
+        log_warning(f"Failed to read file for encoding detection {file_path}: {e}")
+        raise e
+
+    # Open file with detected encoding for streaming
+    @contextlib.contextmanager
+    def _file_context():
+        try:
+            with open(
+                file_path, "r", encoding=detected_encoding, errors="replace"
+            ) as f:
+                yield f
+        except OSError as e:
+            log_warning(f"Failed to open file for streaming {file_path}: {e}")
+            raise e
+
+    return _file_context()
+
+
 def clear_encoding_cache() -> None:
     """Clear the global encoding cache"""
     _encoding_cache.clear()

tree_sitter_analyzer/file_handler.py

@@ -5,9 +5,10 @@ File Handler Module
 This module provides file reading functionality with encoding detection and fallback.
 """
 
+import itertools
 from pathlib import Path
 
-from .encoding_utils import read_file_safe
+from .encoding_utils import read_file_safe, read_file_safe_streaming
 from .utils import setup_logger
 
 # Set up logger for this module
@@ -99,7 +100,10 @@ def read_file_partial(
     end_column: int | None = None,
 ) -> str | None:
     """
-    Read partial file content by line/column range
+    Read partial file content by line/column range using streaming for memory efficiency.
+
+    Performance: Uses streaming approach for 150x speedup on large files.
+    Only loads requested lines into memory instead of entire file.
 
     Args:
         file_path: Path to file
@@ -127,30 +131,39 @@ def read_file_partial(
         return None
 
     try:
-        # Read whole file safely
-        content, detected_encoding = read_file_safe(file_path)
-
-        # Split to lines
-        lines = content.splitlines(keepends=True)
-        total_lines = len(lines)
-
-        # Adjust line indexes
-        start_idx = start_line - 1  # convert to 0-based
-        end_idx = min(
-            end_line - 1 if end_line is not None else total_lines - 1, total_lines - 1
-        )
-
-        # Range check
-        if start_idx >= total_lines:
-            log_warning(
-                f"start_line ({start_line}) exceeds file length ({total_lines})"
-            )
-            return ""
-
-        # Select lines
-        selected_lines = lines[start_idx : end_idx + 1]
+        # Use streaming approach for memory efficiency
+        with read_file_safe_streaming(file_path) as f:
+            # Convert to 0-based indexing
+            start_idx = start_line - 1
+            end_idx = end_line - 1 if end_line is not None else None
+
+            # Use itertools.islice for efficient line selection
+            if end_idx is not None:
+                # Read specific range
+                selected_lines_iter = itertools.islice(f, start_idx, end_idx + 1)
+            else:
+                # Read from start_line to end of file
+                selected_lines_iter = itertools.islice(f, start_idx, None)
+
+            # Convert iterator to list for processing
+            selected_lines = list(selected_lines_iter)
+
+            # Check if we got any lines
+            if not selected_lines:
+                # Check if start_line is beyond file length by counting lines
+                with read_file_safe_streaming(file_path) as f_count:
+                    total_lines = sum(1 for _ in f_count)
+
+                if start_idx >= total_lines:
+                    log_warning(
+                        f"start_line ({start_line}) exceeds file length ({total_lines})"
+                    )
+                    return ""
+                else:
+                    # File might be empty or other issue
+                    return ""
 
-        # Handle column range
+        # Handle column range if specified
         if start_column is not None or end_column is not None:
             processed_lines = []
             for i, line in enumerate(selected_lines):
@@ -185,7 +198,7 @@ def read_file_partial(
                 # Preserve original newline (except last line)
                 if i < len(selected_lines) - 1:
                     # Detect original newline char of the line
-                    original_line = lines[start_idx + i]
+                    original_line = selected_lines[i]
                     if original_line.endswith("\r\n"):
                         line_content += "\r\n"
                     elif original_line.endswith("\n"):
@@ -200,9 +213,12 @@ def read_file_partial(
             # No column range: join lines directly
             result = "".join(selected_lines)
 
+        # Calculate end line for logging
+        actual_end_line = end_line or (start_line + len(selected_lines) - 1)
+
         log_info(
             f"Successfully read partial file {file_path}: "
-            f"lines {start_line}-{end_line or total_lines}"
+            f"lines {start_line}-{actual_end_line}"
             f"{f', columns {start_column}-{end_column}' if start_column is not None or end_column is not None else ''}"
         )
 

tree_sitter_analyzer/languages/java_plugin.py

@@ -1147,11 +1147,15 @@ class JavaPlugin(LanguagePlugin):
             packages = elements_dict.get("packages", [])
             package = packages[0] if packages else None
 
+            # Count nodes in the AST tree
+            node_count = self._count_tree_nodes(tree.root_node) if tree and tree.root_node else 0
+
             return AnalysisResult(
                 file_path=file_path,
                 language="java",
                 line_count=len(file_content.split("\n")),
                 elements=all_elements,
+                node_count=node_count,
                 source_code=file_content,
                 package=package,
             )
@@ -1169,6 +1173,25 @@ class JavaPlugin(LanguagePlugin):
                 success=False,
             )
 
+    def _count_tree_nodes(self, node: Any) -> int:
+        """
+        Recursively count nodes in the AST tree.
+        
+        Args:
+            node: Tree-sitter node
+            
+        Returns:
+            Total number of nodes
+        """
+        if node is None:
+            return 0
+        
+        count = 1  # Count current node
+        if hasattr(node, "children"):
+            for child in node.children:
+                count += self._count_tree_nodes(child)
+        return count
+
     def get_tree_sitter_language(self) -> Any | None:
         """Get the tree-sitter language for Java."""
         if self._cached_language is not None:

tree_sitter_analyzer/mcp/tools/output_format_validator.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+Output format parameter validation for search_content tool.
+
+Ensures mutual exclusion of output format parameters to prevent conflicts
+and provides multilingual error messages with token efficiency guidance.
+"""
+
+import locale
+import os
+from typing import Any
+
+
+class OutputFormatValidator:
+    """Validator for output format parameters mutual exclusion."""
+
+    # Output format parameters that are mutually exclusive
+    OUTPUT_FORMAT_PARAMS = {
+        "total_only",
+        "count_only_matches",
+        "summary_only",
+        "group_by_file",
+        "suppress_output",
+    }
+
+    # Token efficiency guidance for error messages
+    FORMAT_EFFICIENCY_GUIDE = {
+        "total_only": "~10 tokens (most efficient for count queries)",
+        "count_only_matches": "~50-200 tokens (file distribution analysis)",
+        "summary_only": "~500-2000 tokens (initial investigation)",
+        "group_by_file": "~2000-10000 tokens (context-aware review)",
+        "suppress_output": "0 tokens (cache only, no output)",
+    }
+
+    def _detect_language(self) -> str:
+        """Detect preferred language from environment."""
+        # Check environment variables for language preference
+        lang = os.environ.get("LANG", "")
+        if lang.startswith("ja"):
+            return "ja"
+
+        # Check locale
+        try:
+            current_locale = locale.getlocale()[0]
+            if current_locale and current_locale.startswith("ja"):
+                return "ja"
+        except Exception:
+            pass
+
+        # Default to English
+        return "en"
+
+    def _get_error_message(self, specified_formats: list[str]) -> str:
+        """Generate localized error message with usage examples."""
+        lang = self._detect_language()
+        format_list = ", ".join(specified_formats)
+
+        if lang == "ja":
+            # Japanese error message
+            base_message = (
+                f"⚠️ 出力形式パラメータエラー: 相互排他的なパラメータが同時に指定されています: {format_list}\n\n"
+                f"🔒 相互排他的パラメータ: {', '.join(self.OUTPUT_FORMAT_PARAMS)}\n\n"
+                f"💡 トークン効率ガイド:\n"
+            )
+
+            for param, desc in self.FORMAT_EFFICIENCY_GUIDE.items():
+                base_message += f"  • {param}: {desc}\n"
+
+            base_message += (
+                "\n📋 推奨使用パターン:\n"
+                "  • 件数確認: total_only=true\n"
+                "  • ファイル分布: count_only_matches=true\n"
+                "  • 初期調査: summary_only=true\n"
+                "  • 詳細レビュー: group_by_file=true\n"
+                "  • キャッシュのみ: suppress_output=true\n\n"
+                "❌ 間違った例: {\"total_only\": true, \"summary_only\": true}\n"
+                "✅ 正しい例: {\"total_only\": true}"
+            )
+        else:
+            # English error message
+            base_message = (
+                f"⚠️ Output Format Parameter Error: Multiple mutually exclusive formats specified: {format_list}\n\n"
+                f"🔒 Mutually Exclusive Parameters: {', '.join(self.OUTPUT_FORMAT_PARAMS)}\n\n"
+                f"💡 Token Efficiency Guide:\n"
+            )
+
+            for param, desc in self.FORMAT_EFFICIENCY_GUIDE.items():
+                base_message += f"  • {param}: {desc}\n"
+
+            base_message += (
+                "\n📋 Recommended Usage Patterns:\n"
+                "  • Count validation: total_only=true\n"
+                "  • File distribution: count_only_matches=true\n"
+                "  • Initial investigation: summary_only=true\n"
+                "  • Detailed review: group_by_file=true\n"
+                "  • Cache only: suppress_output=true\n\n"
+                "❌ Incorrect: {\"total_only\": true, \"summary_only\": true}\n"
+                "✅ Correct: {\"total_only\": true}"
+            )
+
+        return base_message
+
+    def validate_output_format_exclusion(self, arguments: dict[str, Any]) -> None:
+        """
+        Validate that only one output format parameter is specified.
+
+        Args:
+            arguments: Tool arguments dictionary
+
+        Raises:
+            ValueError: If multiple output format parameters are specified
+        """
+        specified_formats = []
+
+        for param in self.OUTPUT_FORMAT_PARAMS:
+            if arguments.get(param, False):
+                specified_formats.append(param)
+
+        if len(specified_formats) > 1:
+            error_message = self._get_error_message(specified_formats)
+            raise ValueError(error_message)
+
+    def get_active_format(self, arguments: dict[str, Any]) -> str:
+        """
+        Get the active output format from arguments.
+
+        Args:
+            arguments: Tool arguments dictionary
+
+        Returns:
+            Active format name or "normal" if none specified
+        """
+        for param in self.OUTPUT_FORMAT_PARAMS:
+            if arguments.get(param, False):
+                return param
+        return "normal"
+
+
+# Global validator instance
+_default_validator: OutputFormatValidator | None = None
+
+
+def get_default_validator() -> OutputFormatValidator:
+    """Get the default output format validator instance."""
+    global _default_validator
+    if _default_validator is None:
+        _default_validator = OutputFormatValidator()
+    return _default_validator

tree_sitter_analyzer/mcp/tools/search_content_tool.py

@@ -18,6 +18,7 @@ from ..utils.gitignore_detector import get_default_detector
 from ..utils.search_cache import get_default_cache
 from . import fd_rg_utils
 from .base_tool import BaseMCPTool
+from .output_format_validator import get_default_validator
 
 logger = logging.getLogger(__name__)
 
@@ -53,7 +54,26 @@ class SearchContentTool(BaseMCPTool):
     def get_tool_definition(self) -> dict[str, Any]:
         return {
             "name": "search_content",
-            "description": "Search text content inside files using ripgrep. Supports regex patterns, case sensitivity, context lines, and various output formats. Can search in directories or specific files with advanced token optimization (summary_only, group_by_file, total_only, suppress_output).",
+            "description": """Search text content inside files using ripgrep. Supports regex patterns, case sensitivity, context lines, and various output formats. Can search in directories or specific files.
+
+⚡ IMPORTANT: Token Efficiency Guide
+Choose output format parameters based on your needs to minimize token usage and maximize performance with efficient search strategies:
+
+📋 RECOMMENDED WORKFLOW (Most Efficient Approach):
+1. START with total_only=true parameter for initial count validation (~10 tokens)
+2. IF more detail needed, use count_only_matches=true parameter for file distribution (~50-200 tokens)
+3. IF context needed, use summary_only=true parameter for overview (~500-2000 tokens)
+4. ONLY use full results when specific content review is required (~2000-50000+ tokens)
+
+⚡ TOKEN EFFICIENCY COMPARISON:
+- total_only: ~10 tokens (single number) - MOST EFFICIENT for count queries
+- count_only_matches: ~50-200 tokens (file counts) - Good for file distribution analysis
+- summary_only: ~500-2000 tokens (condensed overview) - initial investigation
+- group_by_file: ~2000-10000 tokens (organized by file) - Context-aware review
+- optimize_paths: 10-30% reduction (path compression) - Use with deep directory structures
+- Full results: ~2000-50000+ tokens - Use sparingly for detailed analysis
+
+⚠️ MUTUALLY EXCLUSIVE: Only one output format parameter can be true at a time. Cannot be combined with other format parameters.""",
             "inputSchema": {
                 "type": "object",
                 "properties": {
@@ -144,27 +164,27 @@ class SearchContentTool(BaseMCPTool):
                     "count_only_matches": {
                         "type": "boolean",
                         "default": False,
-                        "description": "Return only match counts per file instead of full match details. Useful for statistics and performance",
+                        "description": "⚡ EXCLUSIVE: Return only match counts per file (~50-200 tokens). RECOMMENDED for: File distribution analysis, understanding match spread across files. Cannot be combined with other output formats.",
                     },
                     "summary_only": {
                         "type": "boolean",
                         "default": False,
-                        "description": "Return a condensed summary of results to reduce context size. Shows top files and sample matches",
+                        "description": "⚡ EXCLUSIVE: Return condensed overview with top files and sample matches (~500-2000 tokens). RECOMMENDED for: Initial investigation, scope confirmation, pattern validation. Cannot be combined with other output formats.",
                     },
                     "optimize_paths": {
                         "type": "boolean",
                         "default": False,
-                        "description": "Optimize file paths in results by removing common prefixes and shortening long paths. Saves tokens in output",
+                        "description": "⚡ EXCLUSIVE: Optimize file paths by removing common prefixes (10-30% token reduction). RECOMMENDED for: Deep directory structures, large codebases. Cannot be combined with other output formats.",
                     },
                     "group_by_file": {
                         "type": "boolean",
                         "default": False,
-                        "description": "Group results by file to eliminate file path duplication when multiple matches exist in the same file. Significantly reduces tokens",
+                        "description": "⚡ EXCLUSIVE: Group results by file, eliminating path duplication (~2000-10000 tokens). RECOMMENDED for: Context-aware review, analyzing matches within specific files. Cannot be combined with other output formats.",
                     },
                     "total_only": {
                         "type": "boolean",
                         "default": False,
-                        "description": "Return only the total match count as a number. Most token-efficient option for count queries. Takes priority over all other formats",
+                        "description": "⚡ EXCLUSIVE: Return only total match count as single number (~10 tokens - MOST EFFICIENT). RECOMMENDED for: Count validation, filtering decisions, existence checks. Takes priority over all other formats. Cannot be combined with other output formats.",
                     },
                     "output_file": {
                         "type": "string",
@@ -217,6 +237,10 @@ class SearchContentTool(BaseMCPTool):
         return validated
 
     def validate_arguments(self, arguments: dict[str, Any]) -> bool:
+        # Validate output format exclusion first
+        validator = get_default_validator()
+        validator.validate_output_format_exclusion(arguments)
+
         if (
             "query" not in arguments
             or not isinstance(arguments["query"], str)

tree_sitter_analyzer/queries/java.py

@@ -107,10 +107,16 @@ JAVA_QUERIES: dict[str, str] = {
       name: (identifier) @name
       body: (block) @body) @method_with_body
     """,
+    # Fixed: Match methods WITH annotations (at least one required)
+    # Uses alternation [(annotation) (marker_annotation)] to match both types:
+    # - marker_annotation: Annotations without parameters (e.g., @Override)
+    # - annotation: Annotations with parameters (e.g., @SuppressWarnings("unchecked"))
+    # The + quantifier requires at least one annotation
     "method_with_annotations": """
     (method_declaration
-      (modifiers (annotation) @annotation)*
-      name: (identifier) @name) @method_with_annotations
+      (modifiers
+        [(annotation) (marker_annotation)]+ @annotation)
+      name: (identifier) @name) @method
     """,
     # --- Inheritance Relations ---
     "extends_clause": """

{tree_sitter_analyzer-1.9.3.dist-info → tree_sitter_analyzer-1.9.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tree-sitter-analyzer
-Version: 1.9.3
+Version: 1.9.4
 Summary: AI-era enterprise-grade code analysis tool with comprehensive HTML/CSS support, dynamic plugin architecture, and MCP integration
 Project-URL: Homepage, https://github.com/aimasteracc/tree-sitter-analyzer
 Project-URL: Documentation, https://github.com/aimasteracc/tree-sitter-analyzer#readme
@@ -199,11 +199,11 @@ Description-Content-Type: text/markdown
 
 [![Python Version](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://python.org)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
-[![Tests](https://img.shields.io/badge/tests-3370%20passed-brightgreen.svg)](#quality-assurance)
+[![Tests](https://img.shields.io/badge/tests-3396%20passed-brightgreen.svg)](#quality-assurance)
 [![Coverage](https://codecov.io/gh/aimasteracc/tree-sitter-analyzer/branch/main/graph/badge.svg)](https://codecov.io/gh/aimasteracc/tree-sitter-analyzer)
 [![Quality](https://img.shields.io/badge/quality-enterprise%20grade-blue.svg)](#quality-assurance)
 [![PyPI](https://img.shields.io/pypi/v/tree-sitter-analyzer.svg)](https://pypi.org/project/tree-sitter-analyzer/)
-[![Version](https://img.shields.io/badge/version-1.9.3-blue.svg)](https://github.com/aimasteracc/tree-sitter-analyzer/releases)
+[![Version](https://img.shields.io/badge/version-1.9.4-blue.svg)](https://github.com/aimasteracc/tree-sitter-analyzer/releases)
 [![zread](https://img.shields.io/badge/Ask_Zread-_.svg?style=flat&color=00b0aa&labelColor=000000&logo=data%3Aimage%2Fsvg%2Bxml%3Bbase64%2CPHN2ZyB3aWR0aD0iMTYiIGhlaWdodD0iMTYiIHZpZXdCb3g9IjAgMCAxNiAxNiIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTQuOTYxNTYgMS42MDAxSDIuMjQxNTZDMS44ODgxIDEuNjAwMSAxLjYwMTU2IDEuODg2NjQgMS42MDE1NiAyLjI0MDFWNC45NjAxQzEuNjAxNTYgNS4zMTM1NiAxLjg4ODEgNS42MDAxIDIuMjQxNTYgNS42MDAxSDQuOTYxNTZDNS4zMTUwMiA1LjYwMDEgNS42MDE1NiA1LjMxMzU2IDUuNjAxNTYgNC45NjAxVjIuMjQwMUM1LjYwMTU2IDEuODg2NjQgNS4zMTUwMiAxLjYwMDEgNC45NjE1NiAxLjYwMDFaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik00Ljk2MTU2IDEwLjM5OTlIMi4yNDE1NkMxLjg4ODEgMTAuMzk5OSAxLjYwMTU2IDEwLjY4NjQgMS42MDE1NiAxMS4wMzk5VjEzLjc1OTlDMS42MDE1NiAxNC4xMTM0IDEuODg4MSAxNC4zOTk5IDIuMjQxNTYgMTQuMzk5OUg0Ljk2MTU2QzUuMzE1MDIgMTQuMzk5OSA1LjYwMTU2IDE0LjExMzQgNS42MDE1NiAxMy43NTk5VjExLjAzOTlDNS42MDE1NiAxMC42ODY0IDUuMzE1MDIgMTAuMzk5OSA0Ljk2MTU2IDEwLjM5OTlaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik0xMy43NTg0IDEuNjAwMUgxMS4wMzg0QzEwLjY4NSAxLjYwMDEgMTAuMzk4NCAxLjg4NjY0IDEwLjM5ODQgMi4yNDAxVjQuOTYwMUMxMC4zOTg0IDUuMzEzNTYgMTAuNjg1IDUuNjAwMSAxMS4wMzg0IDUuNjAwMUgxMy43NTg0QzE0LjExMTkgNS42MDAxIDE0LjM5ODQgNS4zMTM1NiAxNC4zOTg0IDQuOTYwMVYyLjI0MDFDMTQuMzk4NCAxLjg4NjY0IDE0LjExMTkgMS42MDAxIDEzLjc1ODQgMS42MDAxWiIgZmlsbD0iI2ZmZiIvPgo8cGF0aCBkPSJNNCAxMkwxMiA0TDQgMTJaIiBmaWxsPSIjZmZmIi8%2BCjxwYXRoIGQ9Ik00IDEyTDEyIDQiIHN0cm9rZT0iI2ZmZiIgc3Ryb2tlLXdpZHRoPSIxLjUiIHN0cm9rZS1saW5lY2FwPSJyb3VuZCIvPgo8L3N2Zz4K&logoColor=ffffff)](https://zread.ai/aimasteracc/tree-sitter-analyzer)
 [![GitHub Stars](https://img.shields.io/github/stars/aimasteracc/tree-sitter-analyzer.svg?style=social)](https://github.com/aimasteracc/tree-sitter-analyzer)
 
@@ -255,7 +255,7 @@ Tree-sitter Analyzer is an enterprise-grade code analysis tool designed for the
 **Note:** Currently, only the above 7 languages have complete plugin implementations. Languages such as C/C++, Rust, Go, JSON are defined in `LanguageDetector` but do not have functional plugin implementations at this time.
 
 ### 🏆 Production Ready
-- **3,370 Tests** - 100% pass rate, enterprise-grade quality assurance
+- **3,396 Tests** - 100% pass rate, enterprise-grade quality assurance
 - **High Coverage** - Comprehensive test coverage
 - **Cross-platform Support** - Compatible with Windows, macOS, Linux
 - **Continuous Maintenance** - Active development and community support
@@ -336,7 +336,10 @@ rg --version
       "args": [
         "run", "--with", "tree-sitter-analyzer[mcp]",
         "python", "-m", "tree_sitter_analyzer.mcp.server"
-      ]
+      ],
+      "env": {
+        "TREE_SITTER_OUTPUT_PATH": "/absolute/path/to/output/directory"
+      }
     }
   }
 }
@@ -890,20 +893,19 @@ uv run python -m tree_sitter_analyzer --show-query-languages
 ## 8. 🏆 Quality Assurance
 
 ### 📊 Quality Metrics
-- **3,370 tests** - 100% pass rate ✅
+- **3,396 tests** - 100% pass rate ✅
 - **High code coverage** - Comprehensive test suite
 - **Zero test failures** - Production ready
 - **Cross-platform support** - Windows, macOS, Linux
 
-### ⚡ Latest Quality Achievements (v1.8.3)
-- ✅ **🔒 CLI Security Enhancement** - Fixed CLI mode security boundary errors, ensuring file access security
-- ✅ **✅ Argument Validation Improvement** - Implemented complete CLI argument validation system, preventing invalid parameter combinations
-- ✅ **🚫 Exclusive Parameter Control** - `--table` and `--query-key` parameters properly implement exclusive control
-- ✅ **🔍 Enhanced Filter Functionality** - `--query-key` with `--filter` combination usage fully supported
-- ✅ **⚠️ Error Message Optimization** - Provides clear and detailed error information, improving user experience
-- ✅ **🛡️ Project Boundary Protection** - Automatically detects and respects project boundaries, preventing access to sensitive files
-- ✅ **🧪 Test Environment Support** - Temporary directory access permission in test environments
-- ✅ **📋 User Experience Improvement** - More intuitive command-line interface and error handling mechanisms
+### ⚡ Latest Quality Achievements (v1.9.3)
+- ✅ **🎯 Complete Type Safety Achievement** - Reduced mypy errors from 317 to 0, achieving 100% type safety
+- ✅ **🔧 HTML Element Duplication Fix** - Resolved HTML element duplicate detection and Java regex pattern issues
+- ✅ **🧪 Complete Test Suite Success** - All 3,370 tests passing with zero failure rate
+- ✅ **📚 Multilingual Documentation System** - Significant expansion and refinement of Japanese project documentation
+- ✅ **🔄 Parallel Processing Engine Maintained** - search_content supports multi-directory parallel search with up to 4x performance boost
+- ✅ **�️ Enhanced Encoding Processing** - Implementation of automatic encoding detection and UTF-8 processing optimization
+- ✅ **🏗️ Project Management Framework** - Comprehensive project management system including Roo rules and coding checklist
 
 
 ### ⚙️ Running Tests
@@ -941,9 +943,9 @@ The project maintains high-quality test coverage. For detailed module coverage i
 **Verification environment:**
 - Operating systems: Windows 10, macOS, Linux
 - Python version: 3.10+
-- Project version: tree-sitter-analyzer v1.8.2
+- Project version: tree-sitter-analyzer v1.9.3
 - Test files: BigService.java (1419 lines), sample.py (256 lines), MultiClass.java (54 lines)
-- New verification: CLI argument validation, security boundary protection, exclusive parameter control
+- Latest verification: Parallel processing engine, type safety improvements, code style unification
 
 ---
 

{tree_sitter_analyzer-1.9.3.dist-info → tree_sitter_analyzer-1.9.4.dist-info}/RECORD

@@ -1,11 +1,11 @@
-tree_sitter_analyzer/__init__.py,sha256=h8venD4KbRZWV_EpvlWv2bonMO7R-pM44z96eE6rYdc,3067
+tree_sitter_analyzer/__init__.py,sha256=7USPX8uF8wzdeeB748QhRZuz96r8YoEHQ8wzsXRFmDU,3067
 tree_sitter_analyzer/__main__.py,sha256=Zl79tpe4UaMu-7yeztc06tgP0CVMRnvGgas4ZQP5SCs,228
-tree_sitter_analyzer/api.py,sha256=OtT3iduIdr_R7ZRuAkXH18g0nEeL2aBLvEOnlMJfEtQ,22274
+tree_sitter_analyzer/api.py,sha256=1M7n7fa0A1tCXYqSCScQ_6qx08mmTBq1JiK8i66hxq8,31082
 tree_sitter_analyzer/cli_main.py,sha256=AmKeZIUCSI8Gshbz_e1Niquf4pFbpPgtOTwQdLbQgcw,11093
 tree_sitter_analyzer/constants.py,sha256=0kDWsFsMl0sPc2HOt9yPQ_sfHPDW8gaS7TiiJ7EHEO4,1940
-tree_sitter_analyzer/encoding_utils.py,sha256=NHkqOt7GdrxgMsd3k0rVxSO0mWJZXODw3uwl2Qk9ufc,14803
+tree_sitter_analyzer/encoding_utils.py,sha256=PqzQBlPsPHJRaEDdLPqj7_q2K1_yvkVJLH48Rv-73vg,16902
 tree_sitter_analyzer/exceptions.py,sha256=9rEhyn57FOpRFGiZudfwGgCIu_Tx1PinvNUwm-OMWDU,22964
-tree_sitter_analyzer/file_handler.py,sha256=Fb1mG1vTXAiNAAbCU3r-qMtn9hAYVS7YhDeMfNDtMk4,7244
+tree_sitter_analyzer/file_handler.py,sha256=vDIeVpIpCwqIYd97NW5hkiqqkNOdmB_ia2voFHqLPWI,8242
 tree_sitter_analyzer/language_detector.py,sha256=RjA186JAleqB3EhRpqFqRYB7MbRfeXkeoO0K0y_qF6w,17152
 tree_sitter_analyzer/language_loader.py,sha256=6VebTHx_WfXqHz1eCXi69aQ5qm8dpRmN8cW2xSNVckU,9818
 tree_sitter_analyzer/models.py,sha256=N9DZFMLUkCJ9nqFpXwCz8iDB3yGaEQ9DRN3Mnz0-aDs,22676
@@ -33,9 +33,9 @@ tree_sitter_analyzer/cli/commands/table_command.py,sha256=7jdXbnEL2VGDjGHAyNnX8K
 tree_sitter_analyzer/core/__init__.py,sha256=VlYOy1epW16vjaVd__knESewnU0sfXF9a4hjrFxiSEE,440
 tree_sitter_analyzer/core/analysis_engine.py,sha256=MbmW31gmHryimQLr5aCEfhDUr5j0rvdxNNVuD-UOEZI,18821
 tree_sitter_analyzer/core/cache_service.py,sha256=iTFE9JBX8Cd3AULVEO5MjlIF8S73gVyp2v8hmpGjapA,10285
-tree_sitter_analyzer/core/engine.py,sha256=ocrJfSWo-V_Y9qtihTrVDU6aNn3PviAYC7w9TLIh3sU,18367
+tree_sitter_analyzer/core/engine.py,sha256=kby5ySxaXtWQXvc6Ov2DUG2NkQSBqOo_unw6i1vbN0M,19385
 tree_sitter_analyzer/core/parser.py,sha256=qT3yIlTRdod4tf_2o1hU_B-GYGukyM2BtaFxzSoxois,9293
-tree_sitter_analyzer/core/query.py,sha256=fryTvcsrPbRtCBueNoUljwOzqv5e9ykO8Hhcg0NAP80,17337
+tree_sitter_analyzer/core/query.py,sha256=FDJPB1NKuPd0lDdt6W0iW5DwUBIbMxvIc1KLj3wE64A,20544
 tree_sitter_analyzer/core/query_filter.py,sha256=PvGztAZFooFNZe6iHNmbg6RUNtMvq6f6hBZFzllig6Y,6591
 tree_sitter_analyzer/core/query_service.py,sha256=DJRwKT_gvpK4t2fbe5wBRKoqa1r_ztxtzmLYq2-L5BU,12773
 tree_sitter_analyzer/formatters/__init__.py,sha256=yVb4HF_4EEPRwTf3y3-vM2NllrhykG3zlvQhN-6dB4c,31
@@ -57,7 +57,7 @@ tree_sitter_analyzer/interfaces/mcp_server.py,sha256=ms91ExpH7DSV4wOXAePsCB3ATGQ
 tree_sitter_analyzer/languages/__init__.py,sha256=VTXxJgVjHJAciLhX0zzXOS4EygZMtebeYUbi_0z6fGw,340
 tree_sitter_analyzer/languages/css_plugin.py,sha256=1ttM-FSN_43LAZ-vFnQ9tKkAO3BEh3YH7EuemX5tyZw,16341
 tree_sitter_analyzer/languages/html_plugin.py,sha256=0DWzWsZ8zUw4LMyBgE48Vvq0TQ57Qsv2Q5A48_pItec,17977
-tree_sitter_analyzer/languages/java_plugin.py,sha256=0N0TCSxuDW5qypxrYdPmoxYTu0lnMjQ_yv8OtctwgIM,48972
+tree_sitter_analyzer/languages/java_plugin.py,sha256=xaZwUNGUKY2BIzarSLOy6I3SF0Fa2xW-RXG3k2QSiB4,49648
 tree_sitter_analyzer/languages/javascript_plugin.py,sha256=vyRgnKNVzKtJawcxlznVX112P99z9MsDATrr-S8weXs,60363
 tree_sitter_analyzer/languages/markdown_plugin.py,sha256=jkbr9xSNOjeHT8_ATf-R2f1MYoKwqpncb_kzZe1jvcw,77689
 tree_sitter_analyzer/languages/python_plugin.py,sha256=1h17RKV_UII90fSyg0euIvVGjayvhUCHdXDp1KB_QJs,59800
@@ -74,9 +74,10 @@ tree_sitter_analyzer/mcp/tools/base_tool.py,sha256=K02l34Yn6brgg45yIXuSsRPB4Cp87
 tree_sitter_analyzer/mcp/tools/fd_rg_utils.py,sha256=FxJchXLB-tJ3o3GKgJhpG2qBNjbYUDusWqlgGRMWLcY,25460
 tree_sitter_analyzer/mcp/tools/find_and_grep_tool.py,sha256=nhQZ602ZvcIPGEkzireLSLz5RtXugtVu-Nt8vGHS6To,32230
 tree_sitter_analyzer/mcp/tools/list_files_tool.py,sha256=QRy4iXlrO0GXcLcaylNt-TFPwvqrJsO7I4pSOWf4lWQ,18283
+tree_sitter_analyzer/mcp/tools/output_format_validator.py,sha256=NL4JtCv8KwuCuIsrpSQS4pCWtwmUY-yTaJkFOYNAmd0,5440
 tree_sitter_analyzer/mcp/tools/query_tool.py,sha256=XOP21uVKe1J7ayiUnJJBUGls1QTJ5K0GoZ4HlbOr5YE,16887
 tree_sitter_analyzer/mcp/tools/read_partial_tool.py,sha256=O7UyZSNW5_-5hGOkO9xiw4qDY5WKvHtTiGQ_WjhAIA8,18305
-tree_sitter_analyzer/mcp/tools/search_content_tool.py,sha256=H7HISatiPaG5IHcLG1aDi0ndCXKHeN0-y5iWIR1QYDM,36669
+tree_sitter_analyzer/mcp/tools/search_content_tool.py,sha256=bxlVx22Fgn3ZllABjsWxMdxp3ND3tYGj8spIOv9-cVw,38547
 tree_sitter_analyzer/mcp/tools/table_format_tool.py,sha256=Ti-EJxvye09n0jTD9KoL8AP6GZP5jjEPDnAhTy5qIo4,22963
 tree_sitter_analyzer/mcp/tools/universal_analyze_tool.py,sha256=-zZnqN9WcoyRTKM_16ADH859LSebzi34BGYwQL2zCOs,25084
 tree_sitter_analyzer/mcp/utils/__init__.py,sha256=TgTTKsRJAqF95g1fAp5SR_zQVDkImpc_5R0Dw529UUw,3126
@@ -92,7 +93,7 @@ tree_sitter_analyzer/plugins/manager.py,sha256=ccypwnU88ClN8mCRSAzXWL_ihNr0UZ-m7
 tree_sitter_analyzer/queries/__init__.py,sha256=dwDDc7PCw_UWruxSeJ8uEBjY0O5uLDBI5YqyvBhbnN0,696
 tree_sitter_analyzer/queries/css.py,sha256=az5BPZFG2YPI-YbJk1gQXNhpu2ydnyvMaMxA4azpFmQ,17778
 tree_sitter_analyzer/queries/html.py,sha256=QIBs18hJfWNfmjPbcglnq2jsDhvfF1zkNG3KpVzfHIU,14552
-tree_sitter_analyzer/queries/java.py,sha256=Qy-uZWB7REd8hx1zgjNozuAlb7k5hbcBsbCDNJ86bJU,12408
+tree_sitter_analyzer/queries/java.py,sha256=6lEDaUt-jbV9Mlhnslyt6fnudgE12rkufRIwPzyg770,12787
 tree_sitter_analyzer/queries/javascript.py,sha256=seJ5eBR1kAZojCF3p6Rt_X2uP75cJtCF8v5DjQeboHA,22907
 tree_sitter_analyzer/queries/markdown.py,sha256=3Nxe9c1BSHeREPVjmZhQHyVHFwexOiQxLi3AfaLpdW8,6945
 tree_sitter_analyzer/queries/python.py,sha256=pKzua8xu7a6fqbrZZEfA2x8TAl4u9Z_zfE3K1_dUqAM,26188
@@ -104,7 +105,7 @@ tree_sitter_analyzer/security/validator.py,sha256=3dObe1at-EIp8MFV2ePKfSb3oq02j3
 tree_sitter_analyzer/utils/__init__.py,sha256=rfqamPB3eY1CoGXoCjY8RBdLvjmHz0ncIPvvWEGjf2I,1229
 tree_sitter_analyzer/utils/logging.py,sha256=mMBC4E2TV5ngj866iZdZXQQpNYh5LpNZzsdtuoHvKps,16239
 tree_sitter_analyzer/utils/tree_sitter_compat.py,sha256=1bcTUe88CVNzqADlmU23UzSNVlBsnb9E02f7U9VAbpQ,10623
-tree_sitter_analyzer-1.9.3.dist-info/METADATA,sha256=TyvjEkaj4In9ROEKLpP2gsZnu3lvyW3ZtdvhqziqJrU,52991
-tree_sitter_analyzer-1.9.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-tree_sitter_analyzer-1.9.3.dist-info/entry_points.txt,sha256=TJmEXxAMz3og3VPphTHsuE8tNJxf7GuAPjNHwVhXRnc,972
-tree_sitter_analyzer-1.9.3.dist-info/RECORD,,
+tree_sitter_analyzer-1.9.4.dist-info/METADATA,sha256=RaBJI24gktaJmMsMLPYS43sd3RiMnJ_P8N6KodO4568,52969
+tree_sitter_analyzer-1.9.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+tree_sitter_analyzer-1.9.4.dist-info/entry_points.txt,sha256=TJmEXxAMz3og3VPphTHsuE8tNJxf7GuAPjNHwVhXRnc,972
+tree_sitter_analyzer-1.9.4.dist-info/RECORD,,