tree-sitter-analyzer 0.9.4__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/encoding_utils.py

@@ -29,10 +29,13 @@ def _setup_encoding_environment() -> None:
             sys.stderr.reconfigure(encoding="utf-8", errors="replace")
     except Exception as e:
         # Ignore setup errors, use defaults; log at debug when possible
-        try:
-            sys.stderr.write(f"[encoding_setup] non-fatal setup error: {e}\n")
-        except Exception:
-            pass
+        msg = f"[encoding_setup] non-fatal setup error: {e}\n"
+        if hasattr(sys, "stderr") and hasattr(sys.stderr, "write"):
+            try:
+                sys.stderr.write(msg)
+            except Exception:
+                # Swallow secondary I/O errors intentionally
+                ...
 
 
 # Set up environment when module is imported

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}")