tree-sitter-analyzer 0.9.6__py3-none-any.whl → 0.9.8__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.6"
+__version__ = "0.9.7"
 __author__ = "aisheng.yu"
 __email__ = "aimasteracc@gmail.com"
 

tree_sitter_analyzer/core/query_service.py

@@ -1,162 +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
+#!/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/tools/analyze_scale_tool.py

@@ -15,6 +15,7 @@ from ...core.analysis_engine import AnalysisRequest, get_analysis_engine
 from ...language_detector import detect_language_from_file
 from ...security import SecurityValidator
 from ...utils import setup_logger
+from ..utils.path_resolver import PathResolver
 
 # Set up logging
 logger = setup_logger(__name__)
@@ -35,6 +36,7 @@ class AnalyzeScaleTool:
         self.project_root = project_root
         self.analysis_engine = get_analysis_engine(project_root)
         self.security_validator = SecurityValidator(project_root)
+        self.path_resolver = PathResolver(project_root)
         logger.info("AnalyzeScaleTool initialized with security validation")
 
     def _calculate_file_metrics(self, file_path: str) -> dict[str, Any]:
@@ -354,11 +356,17 @@ class AnalyzeScaleTool:
         include_details = arguments.get("include_details", False)
         include_guidance = arguments.get("include_guidance", True)
 
-        # Security validation
-        is_valid, error_msg = self.security_validator.validate_file_path(file_path)
+        # Resolve file path to absolute path
+        resolved_file_path = self.path_resolver.resolve(file_path)
+        logger.info(f"Analyzing file: {file_path} (resolved to: {resolved_file_path})")
+
+        # Security validation using resolved path
+        is_valid, error_msg = self.security_validator.validate_file_path(
+            resolved_file_path
+        )
         if not is_valid:
             logger.warning(
-                f"Security validation failed for file path: {file_path} - {error_msg}"
+                f"Security validation failed for file path: {resolved_file_path} - {error_msg}"
             )
             raise ValueError(f"Invalid file path: {error_msg}")
 
@@ -367,16 +375,20 @@ class AnalyzeScaleTool:
             language = self.security_validator.sanitize_input(language, max_length=50)
 
         # Validate file exists
-        if not Path(file_path).exists():
+        if not Path(resolved_file_path).exists():
             raise ValueError("Invalid file path: file does not exist")
 
         # Detect language if not specified
         if not language:
-            language = detect_language_from_file(file_path)
+            language = detect_language_from_file(resolved_file_path)
             if language == "unknown":
-                raise ValueError(f"Could not detect language for file: {file_path}")
+                raise ValueError(
+                    f"Could not detect language for file: {resolved_file_path}"
+                )
 
-        logger.info(f"Analyzing code scale for {file_path} (language: {language})")
+        logger.info(
+            f"Analyzing code scale for {resolved_file_path} (language: {language})"
+        )
 
         try:
             # Use performance monitoring with proper context manager
@@ -386,14 +398,14 @@ class AnalyzeScaleTool:
                 "analyze_code_scale_enhanced"
             ):
                 # Calculate basic file metrics
-                file_metrics = self._calculate_file_metrics(file_path)
+                file_metrics = self._calculate_file_metrics(resolved_file_path)
 
                 # Use appropriate analyzer based on language
                 if language == "java":
                     # Use AdvancedAnalyzer for comprehensive analysis
                     # Use unified analysis engine instead of deprecated advanced_analyzer
                     request = AnalysisRequest(
-                        file_path=file_path,
+                        file_path=resolved_file_path,
                         language=language,
                         include_complexity=True,
                         include_details=True,
@@ -408,7 +420,7 @@ class AnalyzeScaleTool:
                 else:
                     # Use universal analysis_engine for other languages
                     request = AnalysisRequest(
-                        file_path=file_path,
+                        file_path=resolved_file_path,
                         language=language,
                         include_details=include_details,
                     )

tree_sitter_analyzer/mcp/tools/query_tool.py

@@ -13,6 +13,7 @@ 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
+from ..utils.path_resolver import PathResolver
 
 logger = logging.getLogger(__name__)
 
@@ -25,6 +26,7 @@ class QueryTool:
         self.project_root = project_root
         self.query_service = QueryService(project_root)
         self.security_validator = SecurityValidator(project_root)
+        self.path_resolver = PathResolver(project_root)
 
     def get_tool_definition(self) -> dict[str, Any]:
         """
@@ -41,7 +43,7 @@ class QueryTool:
                 "properties": {
                     "file_path": {
                         "type": "string",
-                        "description": "Path to the code file to query (relative to project root)",
+                        "description": "Path to the code file to query (relative to project root or absolute path)",
                     },
                     "language": {
                         "type": "string",
@@ -74,7 +76,7 @@ class QueryTool:
             },
         }
 
-    @handle_mcp_errors
+    @handle_mcp_errors("query_code")
     async def execute(self, arguments: dict[str, Any]) -> dict[str, Any]:
         """
         Execute query tool
@@ -90,8 +92,18 @@ class QueryTool:
         if not file_path:
             raise ValueError("file_path is required")
 
-        # Security validation
-        validated_path = self.security_validator.validate_file_path(file_path)
+        # Resolve file path to absolute path
+        resolved_file_path = self.path_resolver.resolve(file_path)
+        logger.info(f"Querying file: {file_path} (resolved to: {resolved_file_path})")
+
+        # Security validation using resolved path
+        is_valid, error_msg = self.security_validator.validate_file_path(
+            resolved_file_path
+        )
+        if not is_valid:
+            raise ValueError(
+                f"Invalid or unsafe file path: {error_msg or resolved_file_path}"
+            )
 
         # Get query parameters
         query_key = arguments.get("query_key")
@@ -108,14 +120,14 @@ class QueryTool:
         # Detect language
         language = arguments.get("language")
         if not language:
-            language = detect_language_from_file(validated_path)
+            language = detect_language_from_file(resolved_file_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
+                resolved_file_path, language, query_key, query_string, filter_expression
             )
 
             if not results:

tree_sitter_analyzer/mcp/tools/read_partial_tool.py

@@ -7,13 +7,13 @@ allowing selective content extraction with line and column range support.
 """
 
 import json
-import os
 from pathlib import Path
 from typing import Any
 
 from ...file_handler import read_file_partial
 from ...security import SecurityValidator
 from ...utils import setup_logger
+from ..utils.path_resolver import PathResolver
 
 # Set up logging
 logger = setup_logger(__name__)
@@ -31,6 +31,7 @@ class ReadPartialTool:
         """Initialize the read partial tool."""
         self.security_validator = SecurityValidator(project_root)
         self.project_root = project_root
+        self.path_resolver = PathResolver(project_root)
         logger.info("ReadPartialTool initialized with security validation")
 
     def get_tool_schema(self) -> dict[str, Any]:
@@ -106,20 +107,8 @@ class ReadPartialTool:
         end_column = arguments.get("end_column")
         # output_format = arguments.get("format", "text")  # Not used currently
 
-        # Resolve relative path against project root for consistent behavior
-        base_root = (
-            getattr(
-                getattr(self.security_validator, "boundary_manager", None),
-                "project_root",
-                None,
-            )
-            or self.project_root
-        )
-
-        if not os.path.isabs(file_path) and base_root:
-            resolved_path = os.path.realpath(os.path.join(base_root, file_path))
-        else:
-            resolved_path = file_path
+        # Resolve file path using common path resolver
+        resolved_path = self.path_resolver.resolve(file_path)
 
         # Security validation (validate resolved absolute path when possible)
         is_valid, error_msg = self.security_validator.validate_file_path(resolved_path)

tree_sitter_analyzer/mcp/tools/table_format_tool.py

@@ -1,12 +1,11 @@
 #!/usr/bin/env python3
 """
-Table Format MCP Tool
+Table Format Tool for MCP
 
-This tool provides table-formatted output for code analysis results through the MCP protocol,
-equivalent to the CLI --table=full option functionality.
+This tool provides code structure analysis and table formatting through the MCP protocol,
+converting analysis results into structured table formats for better readability.
 """
 
-import os
 from pathlib import Path
 from typing import Any
 
@@ -16,6 +15,7 @@ from ...security import SecurityValidator
 from ...table_formatter import TableFormatter
 from ...utils import setup_logger
 from ..utils import get_performance_monitor
+from ..utils.path_resolver import PathResolver
 
 # Set up logging
 logger = setup_logger(__name__)
@@ -23,20 +23,19 @@ logger = setup_logger(__name__)
 
 class TableFormatTool:
     """
-    MCP Tool for formatting code analysis results as tables.
+    MCP Tool for code structure analysis and table formatting.
 
-    This tool integrates with existing table_formatter and analyzer components
-    to provide table-formatted output through the MCP protocol, equivalent to
-    the CLI --table=full option.
+    This tool integrates with existing analyzer components to provide
+    structured table output through the MCP protocol.
     """
 
     def __init__(self, project_root: str = None) -> None:
         """Initialize the table format tool."""
-        self.logger = logger
         self.project_root = project_root
         self.analysis_engine = get_analysis_engine(project_root)
         self.security_validator = SecurityValidator(project_root)
-        logger.info("TableFormatTool initialized with security validation")
+        self.path_resolver = PathResolver(project_root)
+        self.logger = logger
 
     def get_tool_schema(self) -> dict[str, Any]:
         """
@@ -272,20 +271,8 @@ class TableFormatTool:
             format_type = args.get("format_type", "full")
             language = args.get("language")
 
-            # Resolve relative path against project root for consistent behavior
-            base_root = (
-                getattr(
-                    getattr(self.security_validator, "boundary_manager", None),
-                    "project_root",
-                    None,
-                )
-                or self.project_root
-            )
-
-            if not os.path.isabs(file_path) and base_root:
-                resolved_path = os.path.realpath(os.path.join(base_root, file_path))
-            else:
-                resolved_path = file_path
+            # Resolve file path using common path resolver
+            resolved_path = self.path_resolver.resolve(file_path)
 
             # Security validation
             is_valid, error_msg = self.security_validator.validate_file_path(