tree-sitter-analyzer 1.9.17.1__py3-none-any.whl

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,340 @@
+#!/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 asyncio
+import logging
+from typing import Any
+
+from ..encoding_utils import read_file_safe
+from ..plugins.manager import PluginManager
+from ..query_loader import query_loader
+from ..utils.tree_sitter_compat import TreeSitterQueryCompat, get_node_text_safe
+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()
+        self.plugin_manager = PluginManager()
+        self.plugin_manager.load_plugins()
+
+    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 = await self._read_file_async(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 using modern API
+            try:
+                captures = TreeSitterQueryCompat.safe_execute_query(
+                    language_obj, query_string or "", tree.root_node, fallback_result=[]
+                )
+
+                # If captures is empty, use plugin fallback
+                if not captures:
+                    captures = self._execute_plugin_query(
+                        tree.root_node, query_key, language, content
+                    )
+
+            except Exception as e:
+                logger.debug(
+                    f"Tree-sitter query execution failed, using plugin fallback: {e}"
+                )
+                # If query creation or execution fails, use plugin fallback
+                captures = self._execute_plugin_query(
+                    tree.root_node, query_key, language, content
+                )
+
+            # Process capture results
+            results = []
+            if isinstance(captures, list):
+                # Handle list of tuples from modern API and plugin execution
+                for capture in captures:
+                    if isinstance(capture, tuple) and len(capture) == 2:
+                        node, name = capture
+                        results.append(self._create_result_dict(node, name, content))
+            # Note: This else block is unreachable due to the logic above, but kept for safety
+            # else:
+            #     # If captures is not in expected format, use plugin fallback
+            #     plugin_captures = self._execute_plugin_query(tree.root_node, query_key, language, content)
+            #     for capture in plugin_captures:
+            #         if isinstance(capture, tuple) and len(capture) == 2:
+            #             node, name = capture
+            #             results.append(self._create_result_dict(node, name, content))
+
+            # 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, source_code: str = ""
+    ) -> dict[str, Any]:
+        """
+        Create result dictionary from tree-sitter node
+
+        Args:
+            node: tree-sitter node
+            capture_name: capture name
+            source_code: source code content for text extraction
+
+        Returns:
+            Result dictionary
+        """
+        # Use safe text extraction with source code
+        content = get_node_text_safe(node, source_code)
+
+        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": content,
+        }
+
+    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
+
+    def _execute_plugin_query(
+        self, root_node: Any, query_key: str | None, language: str, source_code: str
+    ) -> list[tuple[Any, str]]:
+        """
+        Execute query using plugin-based dynamic dispatch
+
+        Args:
+            root_node: Root node of the parsed tree
+            query_key: Query key to execute (can be None for custom queries)
+            language: Programming language
+            source_code: Source code content
+
+        Returns:
+            List of (node, capture_name) tuples
+        """
+        captures = []
+
+        # Try to get plugin for the language
+        plugin = self.plugin_manager.get_plugin(language)
+        if not plugin:
+            logger.warning(f"No plugin found for language: {language}")
+            return self._fallback_query_execution(root_node, query_key)
+
+        # Use plugin's execute_query_strategy method
+        try:
+            # Create a mock tree object for plugin compatibility
+            class MockTree:
+                def __init__(self, root_node: Any) -> None:
+                    self.root_node = root_node
+
+            # Execute plugin query strategy
+            elements = plugin.execute_query_strategy(
+                source_code, query_key or "function"
+            )
+
+            # Convert elements to captures format
+            if elements:
+                for element in elements:
+                    if hasattr(element, "start_line") and hasattr(element, "end_line"):
+                        # Create a mock node for compatibility
+                        class MockNode:
+                            def __init__(self, element: Any) -> None:
+                                self.type = getattr(
+                                    element, "element_type", query_key or "unknown"
+                                )
+                                self.start_point = (
+                                    getattr(element, "start_line", 1) - 1,
+                                    0,
+                                )
+                                self.end_point = (
+                                    getattr(element, "end_line", 1) - 1,
+                                    0,
+                                )
+                                self.text = getattr(element, "raw_text", "").encode(
+                                    "utf-8"
+                                )
+
+                        mock_node = MockNode(element)
+                        captures.append((mock_node, query_key or "element"))
+
+            return captures
+
+        except Exception as e:
+            logger.debug(f"Plugin query strategy failed: {e}")
+
+        # Fallback: Use plugin's element categories for tree traversal
+        try:
+            element_categories = plugin.get_element_categories()
+            if element_categories and query_key and query_key in element_categories:
+                node_types = element_categories[query_key]
+
+                def walk_tree(node: Any) -> None:
+                    """Walk the tree and find matching nodes using plugin categories"""
+                    if node.type in node_types:
+                        captures.append((node, query_key))
+
+                    # Recursively process children
+                    for child in node.children:
+                        walk_tree(child)
+
+                walk_tree(root_node)
+                return captures
+
+        except Exception as e:
+            logger.debug(f"Plugin element categories failed: {e}")
+
+        # Final fallback
+        return self._fallback_query_execution(root_node, query_key)
+
+    def _fallback_query_execution(
+        self, root_node: Any, query_key: str | None
+    ) -> list[tuple[Any, str]]:
+        """
+        Basic fallback query execution for unsupported languages
+
+        Args:
+            root_node: Root node of the parsed tree
+            query_key: Query key to execute
+
+        Returns:
+            List of (node, capture_name) tuples
+        """
+        captures = []
+
+        def walk_tree_basic(node: Any) -> None:
+            """Basic tree walking for unsupported languages"""
+            # Get node type safely
+            node_type = getattr(node, "type", "")
+            if not isinstance(node_type, str):
+                node_type = str(node_type)
+
+            # Generic node type matching (support both singular and plural forms)
+            if (
+                query_key in ("function", "functions")
+                and "function" in node_type
+                or query_key in ("class", "classes")
+                and "class" in node_type
+                or query_key in ("method", "methods")
+                and "method" in node_type
+                or query_key in ("variable", "variables")
+                and "variable" in node_type
+                or query_key in ("import", "imports")
+                and "import" in node_type
+                or query_key in ("header", "headers")
+                and "heading" in node_type
+            ):
+                captures.append((node, query_key))
+
+            # Recursively process children
+            children = getattr(node, "children", [])
+            for child in children:
+                walk_tree_basic(child)
+
+        walk_tree_basic(root_node)
+        return captures
+
+    async def _read_file_async(self, file_path: str) -> tuple[str, str]:
+        """
+        非同期ファイル読み込み
+
+        Args:
+            file_path: ファイルパス
+
+        Returns:
+            tuple[str, str]: (content, encoding)
+        """
+        # CPU集約的でない単純なファイル読み込みなので、
+        # run_in_executorを使用して非同期化
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, read_file_safe, file_path)