tree-sitter-analyzer 0.9.7__py3-none-any.whl → 0.9.8__py3-none-any.whl

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",
@@ -90,12 +92,18 @@ class QueryTool:
         if not file_path:
             raise ValueError("file_path is required")
 
-        # 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"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 file_path}")
-        # Use the original path as validated path after checks
-        validated_path = file_path
+            raise ValueError(
+                f"Invalid or unsafe file path: {error_msg or resolved_file_path}"
+            )
 
         # Get query parameters
         query_key = arguments.get("query_key")
@@ -112,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(

tree_sitter_analyzer/mcp/tools/universal_analyze_tool.py

@@ -1,38 +1,40 @@
 #!/usr/bin/env python3
 """
-Universal Code Analysis Tool for MCP
+Universal Analyze Tool for MCP
 
-This tool provides universal code analysis capabilities for multiple programming
-languages using the existing language detection and analysis infrastructure.
+This tool provides universal code analysis capabilities through the MCP protocol,
+supporting multiple languages with both basic and detailed analysis options.
 """
 
-import logging
 from pathlib import Path
 from typing import Any
 
 from ...core.analysis_engine import AnalysisRequest, get_analysis_engine
 from ...language_detector import detect_language_from_file, is_language_supported
 from ...security import SecurityValidator
+from ...utils import setup_logger
 from ..utils import get_performance_monitor
 from ..utils.error_handler import handle_mcp_errors
+from ..utils.path_resolver import PathResolver
 
-logger = logging.getLogger(__name__)
+# Set up logging
+logger = setup_logger(__name__)
 
 
 class UniversalAnalyzeTool:
     """
-    Universal code analysis tool for multiple programming languages
+    Universal MCP Tool for code analysis across multiple languages.
 
-    This tool automatically detects the programming language and applies
-    the appropriate analyzer to provide comprehensive code analysis.
+    This tool provides comprehensive code analysis capabilities through the MCP protocol,
+    supporting both basic and detailed analysis with language-specific optimizations.
     """
 
-    def __init__(self, project_root: str = None) -> None:
-        """Initialize the universal analysis tool"""
-        # Use unified analysis engine instead of deprecated AdvancedAnalyzer
+    def __init__(self, project_root: str | None = None) -> None:
+        """Initialize the universal analyze tool."""
         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("UniversalAnalyzeTool initialized with security validation")
 
     def get_tool_definition(self) -> dict[str, Any]:
@@ -101,11 +103,17 @@ class UniversalAnalyzeTool:
         language = arguments.get("language")
         analysis_type = arguments.get("analysis_type", "basic")
 
-        # 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}")
 
@@ -120,14 +128,16 @@ class UniversalAnalyzeTool:
         include_queries = arguments.get("include_queries", False)
 
         # 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}"
+                )
 
         # Check if language is supported
         if not is_language_supported(language):
@@ -141,7 +151,7 @@ class UniversalAnalyzeTool:
             )
 
         logger.info(
-            f"Analyzing {file_path} (language: {language}, type: {analysis_type})"
+            f"Analyzing {resolved_file_path} (language: {language}, type: {analysis_type})"
         )
 
         try:
@@ -151,12 +161,12 @@ class UniversalAnalyzeTool:
                 if language == "java":
                     # Use advanced analyzer for Java
                     result = await self._analyze_with_advanced_analyzer(
-                        file_path, language, analysis_type, include_ast
+                        resolved_file_path, language, analysis_type, include_ast
                     )
                 else:
                     # Use universal analyzer for other languages
                     result = await self._analyze_with_universal_analyzer(
-                        file_path, language, analysis_type, include_ast
+                        resolved_file_path, language, analysis_type, include_ast
                     )
 
                 # Add query information if requested
@@ -165,11 +175,11 @@ class UniversalAnalyzeTool:
                         language
                     )
 
-                logger.info(f"Successfully analyzed {file_path}")
+                logger.info(f"Successfully analyzed {resolved_file_path}")
                 return result
 
         except Exception as e:
-            logger.error(f"Error analyzing {file_path}: {e}")
+            logger.error(f"Error analyzing {resolved_file_path}: {e}")
             raise
 
     async def _analyze_with_advanced_analyzer(

tree_sitter_analyzer/mcp/utils/__init__.py

@@ -26,6 +26,9 @@ from .error_handler import (
     handle_mcp_errors,
 )
 
+# Export path resolver utilities
+from .path_resolver import PathResolver, resolve_path
+
 # Module metadata
 __version__ = "2.0.0"
 __author__ = "Tree-Sitter Analyzer Team"
@@ -36,6 +39,7 @@ MCP_UTILS_CAPABILITIES = {
     "features": [
         "Comprehensive Error Handling",
         "Unified Core Services Integration",
+        "Cross-Platform Path Resolution",
     ],
     "deprecated_features": [
         "LRU Cache with TTL (moved to core.cache_service)",
@@ -99,6 +103,9 @@ __all__ = [
     "ErrorCategory",
     "handle_mcp_errors",
     "get_error_handler",
+    # Path resolution
+    "PathResolver",
+    "resolve_path",
     # Backward compatibility
     "get_cache_manager",
     "get_performance_monitor",

tree_sitter_analyzer/mcp/utils/path_resolver.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""
+Path Resolver Utility for MCP Tools
+
+This module provides unified path resolution functionality for all MCP tools,
+ensuring consistent handling of relative and absolute paths across different
+operating systems.
+"""
+
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+
+class PathResolver:
+    """
+    Utility class for resolving file paths in MCP tools.
+
+    Handles relative path resolution against project root and provides
+    cross-platform compatibility for Windows, macOS, and Linux.
+    """
+
+    def __init__(self, project_root: str | None = None):
+        """
+        Initialize the path resolver.
+
+        Args:
+            project_root: Optional project root directory for resolving relative paths
+        """
+        self.project_root = project_root
+        if project_root:
+            # Normalize project root path
+            self.project_root = os.path.normpath(project_root)
+            logger.debug(
+                f"PathResolver initialized with project root: {self.project_root}"
+            )
+
+    def resolve(self, file_path: str) -> str:
+        """
+        Resolve a file path to an absolute path.
+
+        Args:
+            file_path: Input file path (can be relative or absolute)
+
+        Returns:
+            Resolved absolute file path
+
+        Raises:
+            ValueError: If file_path is empty or None
+        """
+        if not file_path:
+            raise ValueError("file_path cannot be empty or None")
+
+        # If already absolute, return as is
+        if os.path.isabs(file_path):
+            resolved_path = os.path.normpath(file_path)
+            logger.debug(f"Path already absolute: {file_path} -> {resolved_path}")
+            return resolved_path
+
+        # If we have a project root, resolve relative to it
+        if self.project_root:
+            resolved_path = os.path.join(self.project_root, file_path)
+            # Normalize path separators for cross-platform compatibility
+            resolved_path = os.path.normpath(resolved_path)
+            logger.debug(
+                f"Resolved relative path '{file_path}' to '{resolved_path}' using project root"
+            )
+            return resolved_path
+
+        # Fallback: try to resolve relative to current working directory
+        resolved_path = os.path.abspath(file_path)
+        resolved_path = os.path.normpath(resolved_path)
+        logger.debug(
+            f"Resolved relative path '{file_path}' to '{resolved_path}' using current working directory"
+        )
+        return resolved_path
+
+    def is_relative(self, file_path: str) -> bool:
+        """
+        Check if a file path is relative.
+
+        Args:
+            file_path: File path to check
+
+        Returns:
+            True if the path is relative, False if absolute
+        """
+        return not os.path.isabs(file_path)
+
+    def get_relative_path(self, absolute_path: str) -> str:
+        """
+        Get the relative path from project root to the given absolute path.
+
+        Args:
+            absolute_path: Absolute file path
+
+        Returns:
+            Relative path from project root, or the original path if no project root
+
+        Raises:
+            ValueError: If absolute_path is not actually absolute
+        """
+        if not os.path.isabs(absolute_path):
+            raise ValueError(f"Path is not absolute: {absolute_path}")
+
+        if not self.project_root:
+            return absolute_path
+
+        try:
+            # Get relative path from project root
+            relative_path = os.path.relpath(absolute_path, self.project_root)
+            logger.debug(
+                f"Converted absolute path '{absolute_path}' to relative path '{relative_path}'"
+            )
+            return relative_path
+        except ValueError:
+            # Paths are on different drives (Windows) or other error
+            logger.warning(
+                f"Could not convert absolute path '{absolute_path}' to relative path"
+            )
+            return absolute_path
+
+    def validate_path(self, file_path: str) -> tuple[bool, str | None]:
+        """
+        Validate if a file path is valid and safe.
+
+        Args:
+            file_path: File path to validate
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        try:
+            resolved_path = self.resolve(file_path)
+
+            # Check if file exists
+            if not os.path.exists(resolved_path):
+                return False, f"File does not exist: {resolved_path}"
+
+            # Check if it's a file (not directory)
+            if not os.path.isfile(resolved_path):
+                return False, f"Path is not a file: {resolved_path}"
+
+            # Check if it's within project root (if we have one)
+            if self.project_root:
+                try:
+                    os.path.commonpath([resolved_path, self.project_root])
+                except ValueError:
+                    return False, f"File path is outside project root: {resolved_path}"
+
+            return True, None
+
+        except Exception as e:
+            return False, f"Path validation error: {str(e)}"
+
+    def get_project_root(self) -> str | None:
+        """
+        Get the current project root.
+
+        Returns:
+            Project root path or None if not set
+        """
+        return self.project_root
+
+    def set_project_root(self, project_root: str) -> None:
+        """
+        Set or update the project root.
+
+        Args:
+            project_root: New project root directory
+        """
+        if project_root:
+            self.project_root = os.path.normpath(project_root)
+            logger.info(f"Project root updated to: {self.project_root}")
+        else:
+            self.project_root = None
+            logger.info("Project root cleared")
+
+
+# Convenience function for backward compatibility
+def resolve_path(file_path: str, project_root: str | None = None) -> str:
+    """
+    Convenience function to resolve a file path.
+
+    Args:
+        file_path: File path to resolve
+        project_root: Optional project root directory
+
+    Returns:
+        Resolved absolute file path
+    """
+    resolver = PathResolver(project_root)
+    return resolver.resolve(file_path)

{tree_sitter_analyzer-0.9.7.dist-info → tree_sitter_analyzer-0.9.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tree-sitter-analyzer
-Version: 0.9.7
+Version: 0.9.8
 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,11 +137,11 @@ Description-Content-Type: text/markdown
 
 [![Python Version](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://python.org)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
-[![Tests](https://img.shields.io/badge/tests-1420%20passed-brightgreen.svg)](#quality-assurance)
-[![Coverage](https://img.shields.io/badge/coverage-74.36%25-green.svg)](#quality-assurance)
+[![Tests](https://img.shields.io/badge/tests-1358%20passed-brightgreen.svg)](#quality-assurance)
+[![Coverage](https://img.shields.io/badge/coverage-74.54%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/)
-[![Version](https://img.shields.io/badge/version-0.9.7-blue.svg)](https://github.com/aimasteracc/tree-sitter-analyzer/releases)
+[![Version](https://img.shields.io/badge/version-0.9.8-blue.svg)](https://github.com/aimasteracc/tree-sitter-analyzer/releases)
 [![GitHub Stars](https://img.shields.io/github/stars/aimasteracc/tree-sitter-analyzer.svg?style=social)](https://github.com/aimasteracc/tree-sitter-analyzer)
 
 ## 🚀 Break Through LLM Token Limits, Let AI Understand Code Files of Any Size
@@ -347,16 +347,21 @@ Parameters: {"file_path": "examples/BigService.java"}
 **Prompt:**
 ```
 Use MCP tool extract_code_section to extract specified code section
-Parameters: {"file_path": "examples/BigService.java", "start_line": 100, "end_line": 105}
+Parameters: {"file_path": "examples/BigService.java", "start_line": 93, "end_line": 105}
 ```
 
 **Return Format:**
 ```json
 {
   "file_path": "examples/BigService.java",
-  "range": {"start_line": 100, "end_line": 105},
-  "content": "Actual code content...",
-  "content_length": 245
+  "range": {
+    "start_line": 93,
+    "end_line": 105,
+    "start_column": null,
+    "end_column": null
+  },
+  "content": "    private void checkMemoryUsage() {\n        Runtime runtime = Runtime.getRuntime();\n        long totalMemory = runtime.totalMemory();\n        long freeMemory = runtime.freeMemory();\n        long usedMemory = totalMemory - freeMemory;\n\n        System.out.println(\"Total Memory: \" + totalMemory);\n        System.out.println(\"Free Memory: \" + freeMemory);\n        System.out.println(\"Used Memory: \" + usedMemory);\n\n        if (usedMemory > totalMemory * 0.8) {\n            System.out.println(\"WARNING: High memory usage detected!\");\n        }\n",
+  "content_length": 542
 }
 ```
 
@@ -551,8 +556,8 @@ Tree-sitter Analyzer automatically detects and protects project boundaries:
 ## 🏆 Quality Assurance
 
 ### 📊 **Quality Metrics**
-- **1,420 Tests** - 100% pass rate ✅
-- **74.36% Code Coverage** - Industry-leading level
+- **1,358 Tests** - 100% pass rate ✅
+- **74.54% Code Coverage** - Industry-leading level
 - **Zero Test Failures** - Complete CI/CD ready
 - **Cross-platform Compatible** - Windows, macOS, Linux
 

{tree_sitter_analyzer-0.9.7.dist-info → tree_sitter_analyzer-0.9.8.dist-info}/RECORD

@@ -53,15 +53,16 @@ tree_sitter_analyzer/mcp/resources/__init__.py,sha256=SWnK8liTQkuQXlVgyRP9mf5Hzp
 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.py,sha256=ZiwIzVbzSMoUXpuC94-N9_xLrlSCWEFlHv2nB_ibOgU,27856
 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=4SlK2FgiMrav64dPKCk3A98qj4henjwfwb0jfcZdpE0,8225
-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
-tree_sitter_analyzer/mcp/utils/__init__.py,sha256=hibcoJc9PEetXqPIpvwHw1cpr1rabAm0QQaDZpxvA_g,2956
+tree_sitter_analyzer/mcp/tools/query_tool.py,sha256=UzJSfVXr6DsF1E8EdysMHxlYOREZOKrym1Zv9OtK_8Y,8545
+tree_sitter_analyzer/mcp/tools/read_partial_tool.py,sha256=Hc4PnF7wBBRhxVlzuqaz1rBA5rWSNvC6qEiWSLqdogI,11504
+tree_sitter_analyzer/mcp/tools/table_format_tool.py,sha256=YeZs5tL8hjWOCR-v6VekNDMyCQOcNI06wHGbGdnacIQ,15451
+tree_sitter_analyzer/mcp/tools/universal_analyze_tool.py,sha256=cdc1K-NZomQK7PD1viVR1kBaNWwDeo1FrU0nn5sb1YA,22141
+tree_sitter_analyzer/mcp/utils/__init__.py,sha256=6f4xTAfA7kCdk3e8r_ee-j7h84OLBEFSNvA3o-TOMqM,3148
 tree_sitter_analyzer/mcp/utils/error_handler.py,sha256=_XeGjfF331EEeHUnJ5cGvJB7WP0lHkD8RXtBayQElr4,18973
+tree_sitter_analyzer/mcp/utils/path_resolver.py,sha256=L9qTXEDwJw3I9nFIQCOdaec0Nuq-6ZvM_UXaOBV-w-c,6196
 tree_sitter_analyzer/plugins/__init__.py,sha256=ITE9bTz7NO4axnn8g5Z-1_ydhSLT0RnY6Y1J9OhUP3E,10326
 tree_sitter_analyzer/plugins/base.py,sha256=FMRAOtjtDutNV8RnB6cmFgdvcjxKRAbrrzqldBBT1yk,17167
 tree_sitter_analyzer/plugins/manager.py,sha256=PyEY3jeuCBpDVqguWhaAu7nzUZM17_pI6wml2e0Hamo,12535
@@ -74,7 +75,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.7.dist-info/METADATA,sha256=bMo6g4c50Z7KemRPJ4nWqzaxiz8O5YNyyJl87CU0iP0,22956
-tree_sitter_analyzer-0.9.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-tree_sitter_analyzer-0.9.7.dist-info/entry_points.txt,sha256=U4tfLGXgCWubKm2PyEb3zxhQ2pm7zVotMyfyS0CodD8,486
-tree_sitter_analyzer-0.9.7.dist-info/RECORD,,
+tree_sitter_analyzer-0.9.8.dist-info/METADATA,sha256=zFg_OCSiYitBph2K6aHC7HRooxgkDN1kbj9WF76FrEU,23557
+tree_sitter_analyzer-0.9.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+tree_sitter_analyzer-0.9.8.dist-info/entry_points.txt,sha256=U4tfLGXgCWubKm2PyEb3zxhQ2pm7zVotMyfyS0CodD8,486
+tree_sitter_analyzer-0.9.8.dist-info/RECORD,,