tree-sitter-analyzer 0.9.5__py3-none-any.whl → 0.9.6__py3-none-any.whl

tree_sitter_analyzer/__init__.py

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

tree_sitter_analyzer/cli/commands/query_command.py

@@ -5,14 +5,50 @@ Query Command
 Handles query execution functionality.
 """
 
+from ...core.query_service import QueryService
 from ...output_manager import output_data, output_error, output_info, output_json
-from ...query_loader import query_loader
 from .base_command import BaseCommand
 
 
 class QueryCommand(BaseCommand):
     """Command for executing queries."""
 
+    def __init__(self, args):
+        """Initialize the query command with QueryService."""
+        super().__init__(args)
+        self.query_service = QueryService()
+
+    async def execute_query(
+        self, language: str, query: str, query_name: str = "custom"
+    ) -> list[dict] | None:
+        """Execute a specific tree-sitter query using QueryService."""
+        try:
+            # Get filter expression if provided
+            filter_expression = getattr(self.args, "filter", None)
+
+            if query_name != "custom":
+                # Use predefined query key
+                results = await self.query_service.execute_query(
+                    self.args.file_path,
+                    language,
+                    query_key=query_name,
+                    filter_expression=filter_expression,
+                )
+            else:
+                # Use custom query string
+                results = await self.query_service.execute_query(
+                    self.args.file_path,
+                    language,
+                    query_string=query,
+                    filter_expression=filter_expression,
+                )
+
+            return results
+
+        except Exception as e:
+            output_error(f"Query execution failed: {e}")
+            return None
+
     async def execute_async(self, language: str) -> int:
         # Get the query to execute
         query_to_execute = None
@@ -22,16 +58,16 @@ class QueryCommand(BaseCommand):
             sanitized_query_key = self.security_validator.sanitize_input(
                 self.args.query_key, max_length=100
             )
-            try:
-                query_to_execute = query_loader.get_query(language, sanitized_query_key)
-                if query_to_execute is None:
-                    output_error(
-                        f"Query '{sanitized_query_key}' not found for language '{language}'"
-                    )
-                    return 1
-            except ValueError as e:
-                output_error(f"{e}")
+            # Check if query exists
+            available_queries = self.query_service.get_available_queries(language)
+            if sanitized_query_key not in available_queries:
+                output_error(
+                    f"Query '{sanitized_query_key}' not found for language '{language}'"
+                )
                 return 1
+            # Store query name - QueryService will resolve the query string
+            query_to_execute = sanitized_query_key  # This is actually the query key now
+            query_name = sanitized_query_key
         elif hasattr(self.args, "query_string") and self.args.query_string:
             # Security check for query string (potential regex patterns)
             is_safe, error_msg = self.security_validator.regex_checker.validate_pattern(
@@ -41,38 +77,17 @@ class QueryCommand(BaseCommand):
                 output_error(f"Unsafe query pattern: {error_msg}")
                 return 1
             query_to_execute = self.args.query_string
+            query_name = "custom"
 
         if not query_to_execute:
             output_error("No query specified.")
             return 1
 
-        # Perform analysis
-        analysis_result = await self.analyze_file(language)
-        if not analysis_result:
+        # Execute specific query
+        results = await self.execute_query(language, query_to_execute, query_name)
+        if results is None:
             return 1
 
-        # Process query results
-        results = []
-        if hasattr(analysis_result, "query_results") and analysis_result.query_results:
-            results = analysis_result.query_results.get("captures", [])
-        else:
-            # Create basic results from elements
-            if hasattr(analysis_result, "elements") and analysis_result.elements:
-                for element in analysis_result.elements:
-                    results.append(
-                        {
-                            "capture_name": getattr(
-                                element, "__class__", type(element)
-                            ).__name__.lower(),
-                            "node_type": getattr(
-                                element, "__class__", type(element)
-                            ).__name__,
-                            "start_line": getattr(element, "start_line", 0),
-                            "end_line": getattr(element, "end_line", 0),
-                            "content": getattr(element, "name", str(element)),
-                        }
-                    )
-
         # Output results
         if results:
             if self.args.output_format == "json":

tree_sitter_analyzer/cli_main.py

@@ -46,6 +46,13 @@ class CLICommandFactory:
         if args.show_supported_extensions:
             return ShowExtensionsCommand(args)
 
+        if args.filter_help:
+            from tree_sitter_analyzer.core.query_filter import QueryFilter
+
+            filter_service = QueryFilter()
+            output_info(filter_service.get_filter_help())
+            return None  # This will exit with code 0
+
         # File analysis commands (require file path)
         if not args.file_path:
             return None
@@ -95,12 +102,23 @@ def create_argument_parser() -> argparse.ArgumentParser:
         "--query-string", help="Directly specify Tree-sitter query to execute"
     )
 
+    # Query filter options
+    parser.add_argument(
+        "--filter",
+        help="Filter query results (e.g., 'name=main', 'name=~get*,public=true')",
+    )
+
     # Information options
     parser.add_argument(
         "--list-queries",
         action="store_true",
         help="Display list of available query keys",
     )
+    parser.add_argument(
+        "--filter-help",
+        action="store_true",
+        help="Display help for query filter syntax",
+    )
     parser.add_argument(
         "--describe-query", help="Display description of specified query key"
     )
@@ -287,6 +305,9 @@ def main() -> None:
     if command:
         exit_code = command.execute()
         sys.exit(exit_code)
+    elif command is None and hasattr(args, "filter_help") and args.filter_help:
+        # filter_help was processed successfully
+        sys.exit(0)
     else:
         if not args.file_path:
             output_error("File path not specified.")

tree_sitter_analyzer/core/query_filter.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+"""
+Query Filter Service
+
+Provides post-processing filtering for query results, supporting filtering by name, parameters, and other conditions.
+"""
+
+import re
+from typing import Any
+
+
+class QueryFilter:
+    """Query result filter"""
+
+    def __init__(self) -> None:
+        pass
+
+    def filter_results(
+        self, results: list[dict[str, Any]], filter_expression: str
+    ) -> list[dict[str, Any]]:
+        """
+        Filter query results based on filter expression
+
+        Args:
+            results: Original query results
+            filter_expression: Filter expression supporting multiple formats:
+                - "name=main" - Exact name match
+                - "name~auth*" - Pattern name match
+                - "params=0" - Filter by parameter count
+                - "static=true" - Filter by modifier
+
+        Returns:
+            Filtered results list
+        """
+        if not filter_expression:
+            return results
+
+        # Parse filter expression
+        filters = self._parse_filter_expression(filter_expression)
+
+        filtered_results = []
+        for result in results:
+            if self._matches_filters(result, filters):
+                filtered_results.append(result)
+
+        return filtered_results
+
+    def _parse_filter_expression(self, expression: str) -> dict[str, Any]:
+        """Parse filter expression"""
+        filters = {}
+
+        # Support multiple conditions separated by commas
+        conditions = expression.split(",")
+
+        for condition in conditions:
+            condition = condition.strip()
+
+            if "=" in condition:
+                key, value = condition.split("=", 1)
+                key = key.strip()
+                value = value.strip()
+
+                # Handle pattern matching
+                if value.startswith("~"):
+                    filters[key] = {"type": "pattern", "value": value[1:]}
+                else:
+                    filters[key] = {"type": "exact", "value": value}
+
+        return filters
+
+    def _matches_filters(self, result: dict[str, Any], filters: dict[str, Any]) -> bool:
+        """Check if result matches all filter conditions"""
+        for filter_key, filter_config in filters.items():
+            if not self._matches_single_filter(result, filter_key, filter_config):
+                return False
+        return True
+
+    def _matches_single_filter(
+        self, result: dict[str, Any], filter_key: str, filter_config: dict[str, Any]
+    ) -> bool:
+        """Check single filter condition"""
+        filter_type = filter_config["type"]
+        filter_value = filter_config["value"]
+
+        if filter_key == "name":
+            return self._match_name(result, filter_type, filter_value)
+        elif filter_key == "params":
+            return self._match_params(result, filter_type, filter_value)
+        elif filter_key == "static":
+            return self._match_modifier(result, "static", filter_value)
+        elif filter_key == "public":
+            return self._match_modifier(result, "public", filter_value)
+        elif filter_key == "private":
+            return self._match_modifier(result, "private", filter_value)
+        elif filter_key == "protected":
+            return self._match_modifier(result, "protected", filter_value)
+
+        return True
+
+    def _match_name(self, result: dict[str, Any], match_type: str, value: str) -> bool:
+        """Match method name"""
+        content = result.get("content", "")
+
+        # Extract method name
+        method_name = self._extract_method_name(content)
+
+        if match_type == "exact":
+            return method_name == value
+        elif match_type == "pattern":
+            # Support wildcard patterns
+            pattern = value.replace("*", ".*")
+            return re.match(pattern, method_name, re.IGNORECASE) is not None
+
+        return False
+
+    def _match_params(
+        self, result: dict[str, Any], match_type: str, value: str
+    ) -> bool:
+        """Match parameter count"""
+        content = result.get("content", "")
+        param_count = self._count_parameters(content)
+
+        try:
+            target_count = int(value)
+            return param_count == target_count
+        except ValueError:
+            return False
+
+    def _match_modifier(
+        self, result: dict[str, Any], modifier: str, value: str
+    ) -> bool:
+        """Match modifier"""
+        content = result.get("content", "")
+        has_modifier = modifier in content
+
+        return (value.lower() == "true") == has_modifier
+
+    def _extract_method_name(self, content: str) -> str:
+        """Extract method name from content"""
+        # Match method declaration patterns
+        patterns = [
+            r"(?:public|private|protected)?\s*(?:static)?\s*\w+\s+(\w+)\s*\(",  # Java method
+            r"def\s+(\w+)\s*\(",  # Python method
+            r"function\s+(\w+)\s*\(",  # JavaScript function
+        ]
+
+        for pattern in patterns:
+            match = re.search(pattern, content)
+            if match:
+                return match.group(1)
+
+        return "unknown"
+
+    def _count_parameters(self, content: str) -> int:
+        """Count method parameters"""
+        # Find parameter list
+        match = re.search(r"\(([^)]*)\)", content)
+        if not match:
+            return 0
+
+        params_str = match.group(1).strip()
+        if not params_str:
+            return 0
+
+        # Simple parameter counting (by comma separation)
+        # Note: This is a simple implementation, doesn't handle generics etc.
+        params = [p.strip() for p in params_str.split(",") if p.strip()]
+        return len(params)
+
+    def get_filter_help(self) -> str:
+        """Get filter help information"""
+        return """
+Filter Syntax Help:
+
+Basic Syntax:
+  --filter "key=value"               # Exact match
+  --filter "key=~pattern"            # Pattern match (supports wildcard *)
+  --filter "key1=value1,key2=value2" # Multiple conditions (AND logic)
+
+Supported filter keys:
+  name       - Method/function name
+             e.g.: name=main, name=~auth*, name=~get*
+
+  params     - Number of parameters
+             e.g.: params=0, params=2
+
+  static     - Whether it is a static method
+             e.g.: static=true, static=false
+
+  public     - Whether it is a public method
+             e.g.: public=true, public=false
+
+  private    - Whether it is a private method
+             e.g.: private=true, private=false
+
+Examples:
+  --query-key methods --filter "name=main"
+  --query-key methods --filter "name=~get*,public=true"
+  --query-key methods --filter "params=0,static=true"
+"""

tree_sitter_analyzer/core/query_service.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""
+Query Service
+
+Unified query service for both CLI and MCP interfaces to avoid code duplication.
+Provides core tree-sitter query functionality including predefined and custom queries.
+"""
+
+import logging
+from typing import Any
+
+from ..encoding_utils import read_file_safe
+from ..query_loader import query_loader
+from .parser import Parser
+from .query_filter import QueryFilter
+
+logger = logging.getLogger(__name__)
+
+
+class QueryService:
+    """Unified query service providing tree-sitter query functionality"""
+
+    def __init__(self, project_root: str | None = None) -> None:
+        """Initialize the query service"""
+        self.project_root = project_root
+        self.parser = Parser()
+        self.filter = QueryFilter()
+
+    async def execute_query(
+        self,
+        file_path: str,
+        language: str,
+        query_key: str | None = None,
+        query_string: str | None = None,
+        filter_expression: str | None = None,
+    ) -> list[dict[str, Any]] | None:
+        """
+        Execute a query
+
+        Args:
+            file_path: Path to the file to analyze
+            language: Programming language
+            query_key: Predefined query key (e.g., 'methods', 'class')
+            query_string: Custom query string (e.g., '(method_declaration) @method')
+            filter_expression: Filter expression (e.g., 'name=main', 'name=~get*,public=true')
+
+        Returns:
+            List of query results, each containing capture_name, node_type, start_line, end_line, content
+
+        Raises:
+            ValueError: If neither query_key nor query_string is provided
+            FileNotFoundError: If file doesn't exist
+            Exception: If query execution fails
+        """
+        if not query_key and not query_string:
+            raise ValueError("Must provide either query_key or query_string")
+
+        if query_key and query_string:
+            raise ValueError("Cannot provide both query_key and query_string")
+
+        try:
+            # Read file content
+            content, encoding = read_file_safe(file_path)
+
+            # Parse file
+            parse_result = self.parser.parse_code(content, language, file_path)
+            if not parse_result or not parse_result.tree:
+                raise Exception("Failed to parse file")
+
+            tree = parse_result.tree
+            language_obj = tree.language if hasattr(tree, "language") else None
+            if not language_obj:
+                raise Exception(f"Language object not available for {language}")
+
+            # Get query string
+            if query_key:
+                query_string = query_loader.get_query(language, query_key)
+                if not query_string:
+                    raise ValueError(
+                        f"Query '{query_key}' not found for language '{language}'"
+                    )
+
+            # Execute tree-sitter query
+            ts_query = language_obj.query(query_string)
+            captures = ts_query.captures(tree.root_node)
+
+            # Process capture results
+            results = []
+            if isinstance(captures, dict):
+                # New tree-sitter API returns dictionary
+                for capture_name, nodes in captures.items():
+                    for node in nodes:
+                        results.append(self._create_result_dict(node, capture_name))
+            else:
+                # Old tree-sitter API returns list of tuples
+                for capture in captures:
+                    if isinstance(capture, tuple) and len(capture) == 2:
+                        node, name = capture
+                        results.append(self._create_result_dict(node, name))
+
+            # Apply filters
+            if filter_expression and results:
+                results = self.filter.filter_results(results, filter_expression)
+
+            return results
+
+        except Exception as e:
+            logger.error(f"Query execution failed: {e}")
+            raise
+
+    def _create_result_dict(self, node: Any, capture_name: str) -> dict[str, Any]:
+        """
+        Create result dictionary from tree-sitter node
+
+        Args:
+            node: tree-sitter node
+            capture_name: capture name
+
+        Returns:
+            Result dictionary
+        """
+        return {
+            "capture_name": capture_name,
+            "node_type": node.type if hasattr(node, "type") else "unknown",
+            "start_line": (
+                node.start_point[0] + 1 if hasattr(node, "start_point") else 0
+            ),
+            "end_line": node.end_point[0] + 1 if hasattr(node, "end_point") else 0,
+            "content": (
+                node.text.decode("utf-8", errors="replace")
+                if hasattr(node, "text") and node.text
+                else ""
+            ),
+        }
+
+    def get_available_queries(self, language: str) -> list[str]:
+        """
+        Get available query keys for specified language
+
+        Args:
+            language: Programming language
+
+        Returns:
+            List of available query keys
+        """
+        return query_loader.list_queries(language)
+
+    def get_query_description(self, language: str, query_key: str) -> str | None:
+        """
+        Get description for query key
+
+        Args:
+            language: Programming language
+            query_key: Query key
+
+        Returns:
+            Query description, or None if not found
+        """
+        try:
+            return query_loader.get_query_description(language, query_key)
+        except Exception:
+            return None

tree_sitter_analyzer/mcp/resources/code_file_resource.py

@@ -135,9 +135,8 @@ class CodeFileResource:
             raise ValueError("File path contains null bytes")
 
         # Check for potentially dangerous path traversal
-        # normalized_path = Path(file_path).resolve()  # Not used currently
         if ".." in file_path:
-            logger.warning(f"Potentially dangerous path traversal in: {file_path}")
+            raise ValueError(f"Path traversal not allowed: {file_path}")
 
         # Additional security checks could be added here
         # For example, restricting to certain directories

tree_sitter_analyzer/mcp/server.py

@@ -51,6 +51,7 @@ from ..utils import setup_logger
 from . import MCP_INFO
 from .resources import CodeFileResource, ProjectStatsResource
 from .tools.base_tool import MCPTool
+from .tools.query_tool import QueryTool
 from .tools.read_partial_tool import ReadPartialTool
 from .tools.table_format_tool import TableFormatTool
 
@@ -77,7 +78,8 @@ class TreeSitterAnalyzerMCPServer:
         self.security_validator = SecurityValidator(project_root)
         # Use unified analysis engine instead of deprecated AdvancedAnalyzer
 
-        # Initialize MCP tools with security validation (three core tools)
+        # Initialize MCP tools with security validation (four core tools)
+        self.query_tool = QueryTool(project_root)  # query_code
         self.read_partial_tool: MCPTool = ReadPartialTool(
             project_root
         )  # extract_code_section
@@ -324,6 +326,7 @@ class TreeSitterAnalyzerMCPServer:
                         "additionalProperties": False,
                     },
                 ),
+                Tool(**self.query_tool.get_tool_definition()),
             ]
 
             logger.info(f"Returning {len(tools)} tools: {[t.name for t in tools]}")
@@ -406,6 +409,9 @@ class TreeSitterAnalyzerMCPServer:
                     self.set_project_path(project_path)
                     result = {"status": "success", "project_root": project_path}
 
+                elif name == "query_code":
+                    result = await self.query_tool.execute(arguments)
+
                 else:
                     raise ValueError(f"Unknown tool: {name}")
 

tree_sitter_analyzer/mcp/tools/query_tool.py

@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+"""
+Query Tool for MCP
+
+MCP tool providing tree-sitter query functionality using unified QueryService.
+Supports both predefined query keys and custom query strings.
+"""
+
+import logging
+from typing import Any
+
+from ...core.query_service import QueryService
+from ...language_detector import detect_language_from_file
+from ...security import SecurityValidator
+from ..utils.error_handler import handle_mcp_errors
+
+logger = logging.getLogger(__name__)
+
+
+class QueryTool:
+    """MCP query tool providing tree-sitter query functionality"""
+
+    def __init__(self, project_root: str | None = None) -> None:
+        """Initialize query tool"""
+        self.project_root = project_root
+        self.query_service = QueryService(project_root)
+        self.security_validator = SecurityValidator(project_root)
+
+    def get_tool_definition(self) -> dict[str, Any]:
+        """
+        Get MCP tool definition
+
+        Returns:
+            Tool definition dictionary
+        """
+        return {
+            "name": "query_code",
+            "description": "Execute tree-sitter queries on code files to extract specific code elements",
+            "inputSchema": {
+                "type": "object",
+                "properties": {
+                    "file_path": {
+                        "type": "string",
+                        "description": "Path to the code file to query (relative to project root)",
+                    },
+                    "language": {
+                        "type": "string",
+                        "description": "Programming language (optional, auto-detected if not provided)",
+                    },
+                    "query_key": {
+                        "type": "string",
+                        "description": "Predefined query key (e.g., 'methods', 'class', 'functions')",
+                    },
+                    "query_string": {
+                        "type": "string",
+                        "description": "Custom tree-sitter query string (e.g., '(method_declaration) @method')",
+                    },
+                    "filter": {
+                        "type": "string",
+                        "description": "Filter expression to refine results (e.g., 'name=main', 'name=~get*,public=true')",
+                    },
+                    "output_format": {
+                        "type": "string",
+                        "enum": ["json", "summary"],
+                        "default": "json",
+                        "description": "Output format",
+                    },
+                },
+                "required": ["file_path"],
+                "anyOf": [
+                    {"required": ["query_key"]},
+                    {"required": ["query_string"]},
+                ],
+            },
+        }
+
+    @handle_mcp_errors
+    async def execute(self, arguments: dict[str, Any]) -> dict[str, Any]:
+        """
+        Execute query tool
+
+        Args:
+            arguments: Tool arguments
+
+        Returns:
+            Query results
+        """
+        # Validate input parameters
+        file_path = arguments.get("file_path")
+        if not file_path:
+            raise ValueError("file_path is required")
+
+        # Security validation
+        validated_path = self.security_validator.validate_file_path(file_path)
+
+        # Get query parameters
+        query_key = arguments.get("query_key")
+        query_string = arguments.get("query_string")
+        filter_expression = arguments.get("filter")
+        output_format = arguments.get("output_format", "json")
+
+        if not query_key and not query_string:
+            raise ValueError("Either query_key or query_string must be provided")
+
+        if query_key and query_string:
+            raise ValueError("Cannot provide both query_key and query_string")
+
+        # Detect language
+        language = arguments.get("language")
+        if not language:
+            language = detect_language_from_file(validated_path)
+            if not language:
+                raise ValueError(f"Could not detect language for file: {file_path}")
+
+        try:
+            # Execute query
+            results = await self.query_service.execute_query(
+                validated_path, language, query_key, query_string, filter_expression
+            )
+
+            if not results:
+                return {
+                    "success": True,
+                    "message": "No results found matching the query",
+                    "results": [],
+                    "count": 0,
+                }
+
+            # Format output
+            if output_format == "summary":
+                return self._format_summary(results, query_key or "custom", language)
+            else:
+                return {
+                    "success": True,
+                    "results": results,
+                    "count": len(results),
+                    "file_path": file_path,
+                    "language": language,
+                    "query": query_key or query_string,
+                }
+
+        except Exception as e:
+            logger.error(f"Query execution failed: {e}")
+            return {
+                "success": False,
+                "error": str(e),
+                "file_path": file_path,
+                "language": language,
+            }
+
+    def _format_summary(
+        self, results: list[dict[str, Any]], query_type: str, language: str
+    ) -> dict[str, Any]:
+        """
+        Format summary output
+
+        Args:
+            results: Query results
+            query_type: Query type
+            language: Programming language
+
+        Returns:
+            Summary formatted results
+        """
+        # Group by capture name
+        by_capture = {}
+        for result in results:
+            capture_name = result["capture_name"]
+            if capture_name not in by_capture:
+                by_capture[capture_name] = []
+            by_capture[capture_name].append(result)
+
+        # Create summary
+        summary = {
+            "success": True,
+            "query_type": query_type,
+            "language": language,
+            "total_count": len(results),
+            "captures": {},
+        }
+
+        for capture_name, items in by_capture.items():
+            summary["captures"][capture_name] = {
+                "count": len(items),
+                "items": [
+                    {
+                        "name": self._extract_name_from_content(item["content"]),
+                        "line_range": f"{item['start_line']}-{item['end_line']}",
+                        "node_type": item["node_type"],
+                    }
+                    for item in items
+                ],
+            }
+
+        return summary
+
+    def _extract_name_from_content(self, content: str) -> str:
+        """
+        Extract name from content (simple heuristic method)
+
+        Args:
+            content: Code content
+
+        Returns:
+            Extracted name
+        """
+        # Simple name extraction logic, can be improved as needed
+        lines = content.strip().split("\n")
+        if lines:
+            first_line = lines[0].strip()
+            # Extract method names, class names, etc.
+            import re
+
+            # Match common declaration patterns
+            patterns = [
+                r"(?:public|private|protected)?\s*(?:static)?\s*(?:class|interface)\s+(\w+)",  # class/interface
+                r"(?:public|private|protected)?\s*(?:static)?\s*\w+\s+(\w+)\s*\(",  # method
+                r"(\w+)\s*\(",  # simple function call
+            ]
+
+            for pattern in patterns:
+                match = re.search(pattern, first_line)
+                if match:
+                    return match.group(1)
+
+        return "unnamed"
+
+    def get_available_queries(self, language: str) -> list[str]:
+        """
+        Get available query keys
+
+        Args:
+            language: Programming language
+
+        Returns:
+            List of available query keys
+        """
+        return self.query_service.get_available_queries(language)

tree_sitter_analyzer/queries/java.py

@@ -356,6 +356,11 @@ ALL_QUERIES["functions"] = {
     "description": "Search all function/method declarations (alias for method)",
 }
 
+ALL_QUERIES["methods"] = {
+    "query": JAVA_QUERIES["method"],
+    "description": "Search all method declarations (alias for method)",
+}
+
 ALL_QUERIES["classes"] = {
     "query": JAVA_QUERIES["class"],
     "description": "Search all class declarations (alias for class)",

{tree_sitter_analyzer-0.9.5.dist-info → tree_sitter_analyzer-0.9.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tree-sitter-analyzer
-Version: 0.9.5
+Version: 0.9.6
 Summary: Extensible multi-language code analyzer framework using Tree-sitter with dynamic plugin architecture
 Project-URL: Homepage, https://github.com/aimasteracc/tree-sitter-analyzer
 Project-URL: Documentation, https://github.com/aimasteracc/tree-sitter-analyzer#readme
@@ -137,8 +137,8 @@ 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-1358%20passed-brightgreen.svg)](#quality-assurance)
-[![Coverage](https://img.shields.io/badge/coverage-74.19%25-green.svg)](#quality-assurance)
+[![Tests](https://img.shields.io/badge/tests-1420%20passed-brightgreen.svg)](#quality-assurance)
+[![Coverage](https://img.shields.io/badge/coverage-74.36%25-green.svg)](#quality-assurance)
 [![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/)
 [![GitHub Stars](https://img.shields.io/github/stars/aimasteracc/tree-sitter-analyzer.svg?style=social)](https://github.com/aimasteracc/tree-sitter-analyzer)
@@ -359,11 +359,49 @@ Parameters: {"file_path": "examples/BigService.java", "start_line": 100, "end_li
 }
 ```
 
+#### 🔍 **Step 4: Smart Query Filtering (NEW!)**
+
+**Find specific methods:**
+```
+Use MCP tool query_code to precisely find code elements
+Parameters: {"file_path": "examples/BigService.java", "query_key": "methods", "filter": "name=main"}
+```
+
+**Find authentication-related methods:**
+```
+Use MCP tool query_code to find authentication methods
+Parameters: {"file_path": "examples/BigService.java", "query_key": "methods", "filter": "name=~auth*"}
+```
+
+**Find parameterless public methods:**
+```
+Use MCP tool query_code to find getter methods
+Parameters: {"file_path": "examples/BigService.java", "query_key": "methods", "filter": "params=0,public=true"}
+```
+
+**Return Format:**
+```json
+{
+  "success": true,
+  "results": [
+    {
+      "capture_name": "method",
+      "node_type": "method_declaration",
+      "start_line": 1385,
+      "end_line": 1418,
+      "content": "public static void main(String[] args) { ... }"
+    }
+  ],
+  "count": 1
+}
+```
+
 #### 💡 **Important Notes**
 - **Parameter Format**: Use snake_case (`file_path`, `start_line`, `end_line`)
 - **Path Handling**: Relative paths auto-resolve to project root
 - **Security Protection**: Tool automatically performs project boundary checks
-- **Workflow**: Recommended to use in order: Step 1 → 2 → 3
+- **Workflow**: Recommended to use in order: Step 1 → 2 → 4 (Query Filtering) → 3 (Precise Extraction)
+- **Filter Syntax**: Supports `name=value`, `name=~pattern*`, `params=number`, `static/public/private=true/false`
 
 ### 🛠️ CLI Command Examples
 
@@ -379,6 +417,22 @@ uv run python -m tree_sitter_analyzer examples/BigService.java --partial-read --
 
 # Silent mode (display results only)
 uv run python -m tree_sitter_analyzer examples/BigService.java --table=full --quiet
+
+# 🔍 Query filtering examples (NEW!)
+# Find specific methods
+uv run python -m tree_sitter_analyzer examples/BigService.java --query-key methods --filter "name=main"
+
+# Find authentication-related methods
+uv run python -m tree_sitter_analyzer examples/BigService.java --query-key methods --filter "name=~auth*"
+
+# Find parameterless public methods
+uv run python -m tree_sitter_analyzer examples/BigService.java --query-key methods --filter "params=0,public=true"
+
+# Find static methods
+uv run python -m tree_sitter_analyzer examples/BigService.java --query-key methods --filter "static=true"
+
+# View filter syntax help
+uv run python -m tree_sitter_analyzer --filter-help
 ```
 
 ---
@@ -398,6 +452,15 @@ Get insights without reading complete files:
 - Include position metadata
 - Support efficient processing of large files
 
+### 🔍 **Advanced Query Filtering**
+Powerful code element querying and filtering system:
+- **Exact matching**: `--filter "name=main"` Find specific methods
+- **Pattern matching**: `--filter "name=~auth*"` Find authentication-related methods  
+- **Parameter filtering**: `--filter "params=2"` Find methods with specific parameter counts
+- **Modifier filtering**: `--filter "static=true,public=true"` Find static public methods
+- **Compound conditions**: `--filter "name=~get*,params=0,public=true"` Combine multiple conditions
+- **CLI/MCP consistency**: Same filtering syntax in command line and AI assistants
+
 ### 🔗 **AI Assistant Integration**
 Deep integration via MCP protocol:
 - Claude Desktop
@@ -482,16 +545,16 @@ Tree-sitter Analyzer automatically detects and protects project boundaries:
 ## 🏆 Quality Assurance
 
 ### 📊 **Quality Metrics**
-- **1,358 Tests** - 100% pass rate ✅
-- **74.54% Code Coverage** - Industry-leading level
+- **1,420 Tests** - 100% pass rate ✅
+- **74.36% Code Coverage** - Industry-leading level
 - **Zero Test Failures** - Complete CI/CD ready
 - **Cross-platform Compatible** - Windows, macOS, Linux
 
-### ⚡ **Latest Quality Achievements (v0.9.4)**
-- ✅ **Test Suite Completely Stable** - Fixed all historical issues
-- ✅ **Formatter Module Breakthrough** - Coverage significantly improved
-- ✅ **Error Handling Optimization** - Enterprise-grade exception handling
-- ✅ **100+ New Comprehensive Tests** - Covering critical modules
+### ⚡ **Latest Quality Achievements (v0.9.6)**
+- ✅ **Smart Query Filtering System** - 62 new tests all passed
+- ✅ **Unified Architecture Design** - QueryService eliminates code duplication
+- ✅ **CI Test Fixes** - All platforms test stable
+- ✅ **Multi-language Documentation** - Complete updates in EN/ZH/JA
 
 ### ⚙️ **Running Tests**
 ```bash
@@ -507,9 +570,10 @@ uv run pytest tests/test_mcp_server_initialization.py -v
 
 ### 📈 **Coverage Highlights**
 - **Language Detector**: 98.41% (Excellent)
-- **CLI Main Entry**: 97.78% (Excellent)
+- **CLI Main Entry**: 94.36% (Excellent)
+- **Query Filtering System**: 96.06% (Excellent)
+- **Query Service**: 86.25% (Good)
 - **Error Handling**: 82.76% (Good)
-- **Security Framework**: 78%+ (Reliable)
 
 ---
 

{tree_sitter_analyzer-0.9.5.dist-info → tree_sitter_analyzer-0.9.6.dist-info}/RECORD

@@ -1,7 +1,7 @@
-tree_sitter_analyzer/__init__.py,sha256=ElX-1qL0OI5EuUf2XVkdqvLuWwRgTVYDGDnyeuLUBww,3067
+tree_sitter_analyzer/__init__.py,sha256=JBnnkxDQchD9fes65p315c62-Pat2QTvNGRKaeumtDo,3067
 tree_sitter_analyzer/__main__.py,sha256=Zl79tpe4UaMu-7yeztc06tgP0CVMRnvGgas4ZQP5SCs,228
 tree_sitter_analyzer/api.py,sha256=naRtGuZ27AIVfn6Rid0zQcHDI71UpO9Nh4NQM9JyD3c,16954
-tree_sitter_analyzer/cli_main.py,sha256=R03sPnWD_39u1wxpr7nd97EHe8jlp2npViiPbfm_cHo,9644
+tree_sitter_analyzer/cli_main.py,sha256=4uIwje6n2qQvTsX4RBgqFgznxJs8RcCnS1GQjrR5IGQ,10354
 tree_sitter_analyzer/encoding_utils.py,sha256=NHkqOt7GdrxgMsd3k0rVxSO0mWJZXODw3uwl2Qk9ufc,14803
 tree_sitter_analyzer/exceptions.py,sha256=AZryCQyKXekAg8lQZd3zqULnjhCKovBNNpnUlNGDhcI,11615
 tree_sitter_analyzer/file_handler.py,sha256=nUD17QIdOJ2bnXekuo-QzGQFv0f2rxCSJi-zWeQFSAs,6636
@@ -21,7 +21,7 @@ tree_sitter_analyzer/cli/commands/advanced_command.py,sha256=xDZI4zKTMHNdf7fc_QN
 tree_sitter_analyzer/cli/commands/base_command.py,sha256=o_xjKhn2J5bbGeNC980tALozT1WlsttI0owhLbV2hDM,6597
 tree_sitter_analyzer/cli/commands/default_command.py,sha256=RAR_eaOK3EndIqU7QL5UAn44mwyhItTN7aUaKL1WmSc,524
 tree_sitter_analyzer/cli/commands/partial_read_command.py,sha256=RGZsEBybu6PhOQDHBXuhs6l4ZlDcFaxj2bNOvSqKY80,4605
-tree_sitter_analyzer/cli/commands/query_command.py,sha256=vpvCKxKGOaOHiNV_7UjW7JV5tAGAAx7AB9sV2EbLEyc,3612
+tree_sitter_analyzer/cli/commands/query_command.py,sha256=VFuCFJxffjSUrMa7NB_KJmMexUnJmnazpTDbw-i9Ulw,4003
 tree_sitter_analyzer/cli/commands/structure_command.py,sha256=0iJwjOgtW838hXleXogWhbu6eQFfrLR1QgKe5PFBqvU,5220
 tree_sitter_analyzer/cli/commands/summary_command.py,sha256=02WA3sOzfT83FVT6sW7nK04zVcZ9Qj_1S0WloqlTnFk,3602
 tree_sitter_analyzer/cli/commands/table_command.py,sha256=GvGpLZ_YwE5syufNMfvjPrzwt-bXUtAF7EoOQ0Dr_O0,9441
@@ -31,6 +31,8 @@ tree_sitter_analyzer/core/cache_service.py,sha256=0oZGuTpeHBKYNdnqAOVi6VlQukYMIH
 tree_sitter_analyzer/core/engine.py,sha256=VFXGowDj6EfjFSh2MQDkQIc-4ISXaOg38n4lUhVY5Os,18721
 tree_sitter_analyzer/core/parser.py,sha256=qT3yIlTRdod4tf_2o1hU_B-GYGukyM2BtaFxzSoxois,9293
 tree_sitter_analyzer/core/query.py,sha256=UhQxUmQitFobe2YM7Ifhi3X2WdHVb02KzeBunueYJ4I,16397
+tree_sitter_analyzer/core/query_filter.py,sha256=PvGztAZFooFNZe6iHNmbg6RUNtMvq6f6hBZFzllig6Y,6591
+tree_sitter_analyzer/core/query_service.py,sha256=j9v3w2j3axhxzFEbZLovDNT2h6kF4PWbJVL_PmKl3ho,5542
 tree_sitter_analyzer/formatters/__init__.py,sha256=yVb4HF_4EEPRwTf3y3-vM2NllrhykG3zlvQhN-6dB4c,31
 tree_sitter_analyzer/formatters/base_formatter.py,sha256=Uv6uVgUKwbBn6of26bnvr4u6CmX2ka1a405VL17CGFU,5763
 tree_sitter_analyzer/formatters/formatter_factory.py,sha256=mCnAbEHycoSttSuF4dU78hzcxyg-h57bo0_bj00zw58,2069
@@ -46,14 +48,15 @@ tree_sitter_analyzer/languages/java_plugin.py,sha256=ZTtDgyUdv-b9fFvCMEL3xS-yr0r
 tree_sitter_analyzer/languages/javascript_plugin.py,sha256=k14kHfi5II9MRTsVuy0NQq5l2KZYncCnM1Q6T1c5q_U,15844
 tree_sitter_analyzer/languages/python_plugin.py,sha256=MJ03F_Nv-nmInIkEFmPyEXYhyGbLHyr5kCbj2taEDYk,29144
 tree_sitter_analyzer/mcp/__init__.py,sha256=Dj4aqt_6inDKQ1xmA6DNMNDQBHzToqBjSWazdAWZgCY,944
-tree_sitter_analyzer/mcp/server.py,sha256=e_Enu0MoEuWISFW0XQxcU-_db5jwCQY5txfVkqTO-7U,24788
+tree_sitter_analyzer/mcp/server.py,sha256=93baLte6ub2rnxr5EKfeknpN1t2BWraTm6Mk4imvHVU,25068
 tree_sitter_analyzer/mcp/resources/__init__.py,sha256=SWnK8liTQkuQXlVgyRP9mf5HzpqmqohShrC98xlNnDc,1389
-tree_sitter_analyzer/mcp/resources/code_file_resource.py,sha256=POhQ1xPMiGBVVm6AfOQNKM29svDLvlGLA97ZPQgVoHw,6253
+tree_sitter_analyzer/mcp/resources/code_file_resource.py,sha256=ZX5ZYSJfylBedpL80kTDlco2YZqgRMb5f3OW0VvOVRM,6166
 tree_sitter_analyzer/mcp/resources/project_stats_resource.py,sha256=V5-daZ99SU4rOt7qLk9GmhkzdXJpEINBobNlT14ojYY,19441
 tree_sitter_analyzer/mcp/tools/__init__.py,sha256=u7JrSLwE95y50mfjSus6HRdtdhkNbVrW8jP4AooawEU,762
 tree_sitter_analyzer/mcp/tools/analyze_scale_tool.py,sha256=cVBhq4_KxwcqdmA5s9iZLH4YDy7T_TKLNNdqqaGKnFU,27369
 tree_sitter_analyzer/mcp/tools/analyze_scale_tool_cli_compatible.py,sha256=mssed7bEfGeGxW4mOf7dg8BDS1oqHLolIBNX9DaZ3DM,8997
 tree_sitter_analyzer/mcp/tools/base_tool.py,sha256=FVSMgKIliQ5EBVQEfjYwWeqzWt9OqOFDr3dyACIDxig,1210
+tree_sitter_analyzer/mcp/tools/query_tool.py,sha256=FBsxsWhoSYA0ql_IaMGSLR6vmg3M4b1rDsYZsZuVGWQ,7996
 tree_sitter_analyzer/mcp/tools/read_partial_tool.py,sha256=MkAeXc-n-8fxRGtE3RQ_yZOPQ1lzdUppVFKrRzBPogU,11790
 tree_sitter_analyzer/mcp/tools/table_format_tool.py,sha256=flFEcDOozJSJOtsQVHsk5eTYsutBi_T_2ft9XUpceSM,15896
 tree_sitter_analyzer/mcp/tools/universal_analyze_tool.py,sha256=RSbztW_b07DL5e1an4BE--snX744v4KmlRGab5bGj6U,21677
@@ -63,7 +66,7 @@ tree_sitter_analyzer/plugins/__init__.py,sha256=ITE9bTz7NO4axnn8g5Z-1_ydhSLT0RnY
 tree_sitter_analyzer/plugins/base.py,sha256=FMRAOtjtDutNV8RnB6cmFgdvcjxKRAbrrzqldBBT1yk,17167
 tree_sitter_analyzer/plugins/manager.py,sha256=PyEY3jeuCBpDVqguWhaAu7nzUZM17_pI6wml2e0Hamo,12535
 tree_sitter_analyzer/queries/__init__.py,sha256=dwDDc7PCw_UWruxSeJ8uEBjY0O5uLDBI5YqyvBhbnN0,696
-tree_sitter_analyzer/queries/java.py,sha256=NZTSzFADlGrm3MD0oIkOdkN_6wP2pGZpNs0Rb7I_mcw,12249
+tree_sitter_analyzer/queries/java.py,sha256=avaPFeHz3Ig-yTdCDKfUKaG-5sktOEkrXG2p9_mEZVs,12388
 tree_sitter_analyzer/queries/javascript.py,sha256=pnXrgISwDE5GhPHDbUKEGI3thyLmebTeQt-l_-x4qT8,3962
 tree_sitter_analyzer/queries/python.py,sha256=L33KRUyV3sAvA3_HFkPyGgtiq0ygSpNY_n2YojodPlc,7570
 tree_sitter_analyzer/queries/typescript.py,sha256=eersyAF7TladuCWa8WE_-cO9YTF1LUSjLIl-tk2fZDo,6708
@@ -71,7 +74,7 @@ tree_sitter_analyzer/security/__init__.py,sha256=ZTqTt24hsljCpTXAZpJC57L7MU5lJLT
 tree_sitter_analyzer/security/boundary_manager.py,sha256=CUQWU5j1zdjEbN9UmArcYkq9HbemhttQzk0pVk-vxZs,8153
 tree_sitter_analyzer/security/regex_checker.py,sha256=jWK6H8PTPgzbwRPfK_RZ8bBTS6rtEbgjY5vr3YWjQ_U,9616
 tree_sitter_analyzer/security/validator.py,sha256=UPAPcrnmI2mNzbYOm0MabnJMGllK6HlOQ9KX-2bRfgU,8986
-tree_sitter_analyzer-0.9.5.dist-info/METADATA,sha256=j7tFOFQLvwciwHpyidLtuy4t8oKp_rkhLuKWgBMzgg8,20191
-tree_sitter_analyzer-0.9.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-tree_sitter_analyzer-0.9.5.dist-info/entry_points.txt,sha256=U4tfLGXgCWubKm2PyEb3zxhQ2pm7zVotMyfyS0CodD8,486
-tree_sitter_analyzer-0.9.5.dist-info/RECORD,,
+tree_sitter_analyzer-0.9.6.dist-info/METADATA,sha256=_bMzqpiKdK1seg16PqwJhmF2vxPGsPL3HkB48XSNhVg,22608
+tree_sitter_analyzer-0.9.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+tree_sitter_analyzer-0.9.6.dist-info/entry_points.txt,sha256=U4tfLGXgCWubKm2PyEb3zxhQ2pm7zVotMyfyS0CodD8,486
+tree_sitter_analyzer-0.9.6.dist-info/RECORD,,