tree-sitter-analyzer 1.7.5__py3-none-any.whl → 1.7.7__py3-none-any.whl

tree_sitter_analyzer/__init__.py

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

tree_sitter_analyzer/api.py

@@ -11,6 +11,7 @@ import logging
 from pathlib import Path
 from typing import Any
 
+from . import __version__
 from .core.engine import AnalysisEngine
 from .utils import log_error
 
@@ -500,7 +501,7 @@ def get_framework_info() -> dict[str, Any]:
 
         return {
             "name": "tree-sitter-analyzer",
-            "version": "2.0.0",  # New architecture version
+            "version": __version__,
             "supported_languages": engine.get_supported_languages(),
             "total_languages": len(engine.get_supported_languages()),
             "plugin_info": {
@@ -521,7 +522,7 @@ def get_framework_info() -> dict[str, Any]:
         }
     except Exception as e:
         log_error(f"Failed to get framework info: {e}")
-        return {"name": "tree-sitter-analyzer", "version": "2.0.0", "error": str(e)}
+        return {"name": "tree-sitter-analyzer", "version": __version__, "error": str(e)}
 
 
 def execute_query(

tree_sitter_analyzer/exceptions.py

@@ -398,3 +398,337 @@ class RegexSecurityError(SecurityError):
         )
         self.pattern = pattern
         self.dangerous_construct = dangerous_construct
+
+
+# MCP-specific exceptions for enhanced error handling
+class MCPToolError(MCPError):
+    """Raised when MCP tool execution fails."""
+    
+    def __init__(
+        self,
+        message: str,
+        tool_name: str | None = None,
+        input_params: dict[str, Any] | None = None,
+        execution_stage: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        context = kwargs.get("context", {})
+        if input_params:
+            # Sanitize sensitive information from input params
+            sanitized_params = self._sanitize_params(input_params)
+            context["input_params"] = sanitized_params
+        if execution_stage:
+            context["execution_stage"] = execution_stage
+        
+        super().__init__(message, tool_name=tool_name, context=context, **kwargs)
+        self.input_params = input_params
+        self.execution_stage = execution_stage
+    
+    @staticmethod
+    def _sanitize_params(params: dict[str, Any]) -> dict[str, Any]:
+        """Sanitize sensitive information from parameters."""
+        sanitized = {}
+        sensitive_keys = {"password", "token", "key", "secret", "auth", "credential"}
+        
+        for key, value in params.items():
+            if any(sensitive in key.lower() for sensitive in sensitive_keys):
+                sanitized[key] = "***REDACTED***"
+            elif isinstance(value, str) and len(value) > 100:
+                sanitized[key] = value[:100] + "...[TRUNCATED]"
+            else:
+                sanitized[key] = value
+        
+        return sanitized
+
+
+class MCPResourceError(MCPError):
+    """Raised when MCP resource access fails."""
+    
+    def __init__(
+        self,
+        message: str,
+        resource_uri: str | None = None,
+        resource_type: str | None = None,
+        access_mode: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        context = kwargs.get("context", {})
+        if resource_type:
+            context["resource_type"] = resource_type
+        if access_mode:
+            context["access_mode"] = access_mode
+        
+        super().__init__(message, resource_uri=resource_uri, context=context, **kwargs)
+        self.resource_type = resource_type
+        self.access_mode = access_mode
+
+
+class MCPTimeoutError(MCPError):
+    """Raised when MCP operation times out."""
+    
+    def __init__(
+        self,
+        message: str,
+        timeout_seconds: float | None = None,
+        operation_type: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        context = kwargs.get("context", {})
+        if timeout_seconds:
+            context["timeout_seconds"] = timeout_seconds
+        if operation_type:
+            context["operation_type"] = operation_type
+        
+        super().__init__(message, context=context, **kwargs)
+        self.timeout_seconds = timeout_seconds
+        self.operation_type = operation_type
+
+
+class MCPValidationError(ValidationError):
+    """Raised when MCP input validation fails."""
+    
+    def __init__(
+        self,
+        message: str,
+        tool_name: str | None = None,
+        parameter_name: str | None = None,
+        parameter_value: Any | None = None,
+        validation_rule: str | None = None,
+        **kwargs: Any,
+    ) -> None:
+        context = kwargs.get("context", {})
+        if tool_name:
+            context["tool_name"] = tool_name
+        if parameter_name:
+            context["parameter_name"] = parameter_name
+        if validation_rule:
+            context["validation_rule"] = validation_rule
+        
+        # Sanitize parameter value for logging
+        if parameter_value is not None:
+            if isinstance(parameter_value, str) and len(parameter_value) > 200:
+                context["parameter_value"] = parameter_value[:200] + "...[TRUNCATED]"
+            else:
+                context["parameter_value"] = parameter_value
+        
+        super().__init__(message, validation_type="mcp_parameter", context=context, **kwargs)
+        self.tool_name = tool_name
+        self.parameter_name = parameter_name
+        self.validation_rule = validation_rule
+
+
+class FileRestrictionError(SecurityError):
+    """Raised when file access is restricted by mode or security policy."""
+    
+    def __init__(
+        self,
+        message: str,
+        file_path: str | Path | None = None,
+        current_mode: str | None = None,
+        allowed_patterns: list[str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        context = kwargs.get("context", {})
+        if current_mode:
+            context["current_mode"] = current_mode
+        if allowed_patterns:
+            context["allowed_patterns"] = allowed_patterns
+        
+        super().__init__(
+            message,
+            security_type="file_restriction",
+            file_path=file_path,
+            context=context,
+            **kwargs
+        )
+        self.current_mode = current_mode
+        self.allowed_patterns = allowed_patterns
+
+
+# Enhanced error response utilities for MCP
+def create_mcp_error_response(
+    exception: Exception,
+    tool_name: str | None = None,
+    include_debug_info: bool = False,
+    sanitize_sensitive: bool = True,
+) -> dict[str, Any]:
+    """
+    Create standardized MCP error response dictionary.
+    
+    Args:
+        exception: The exception to convert
+        tool_name: Name of the MCP tool that failed
+        include_debug_info: Whether to include debug information
+        sanitize_sensitive: Whether to sanitize sensitive information
+    
+    Returns:
+        MCP-compliant error response dictionary
+    """
+    import traceback
+    
+    response: dict[str, Any] = {
+        "success": False,
+        "error": {
+            "type": exception.__class__.__name__,
+            "message": str(exception),
+            "timestamp": __import__("datetime").datetime.utcnow().isoformat() + "Z"
+        }
+    }
+    
+    # Add tool name if provided
+    if tool_name:
+        response["error"]["tool"] = tool_name
+    
+    # Add context if available
+    if hasattr(exception, "context") and exception.context:
+        context = exception.context.copy()
+        
+        # Sanitize sensitive information if requested
+        if sanitize_sensitive:
+            context = _sanitize_error_context(context)
+        
+        response["error"]["context"] = context
+    
+    # Add error code if available
+    if hasattr(exception, "error_code"):
+        response["error"]["code"] = exception.error_code
+    
+    # Add debug information if requested
+    if include_debug_info:
+        response["error"]["debug"] = {
+            "traceback": traceback.format_exc(),
+            "exception_args": list(exception.args) if exception.args else []
+        }
+    
+    # Add specific error details for known exception types
+    if isinstance(exception, MCPToolError):
+        response["error"]["execution_stage"] = exception.execution_stage
+    elif isinstance(exception, MCPTimeoutError):
+        response["error"]["timeout_seconds"] = exception.timeout_seconds
+    elif isinstance(exception, FileRestrictionError):
+        response["error"]["current_mode"] = exception.current_mode
+        response["error"]["allowed_patterns"] = exception.allowed_patterns
+    
+    return response
+
+
+def _sanitize_error_context(context: dict[str, Any]) -> dict[str, Any]:
+    """Sanitize sensitive information from error context."""
+    sanitized = {}
+    sensitive_keys = {
+        "password", "token", "key", "secret", "auth", "credential",
+        "api_key", "access_token", "private_key", "session_id"
+    }
+    
+    for key, value in context.items():
+        if any(sensitive in key.lower() for sensitive in sensitive_keys):
+            sanitized[key] = "***REDACTED***"
+        elif isinstance(value, str) and len(value) > 500:
+            sanitized[key] = value[:500] + "...[TRUNCATED]"
+        elif isinstance(value, (list, tuple)) and len(value) > 10:
+            sanitized[key] = list(value[:10]) + ["...[TRUNCATED]"]
+        elif isinstance(value, dict) and len(value) > 20:
+            # Recursively sanitize nested dictionaries
+            truncated_dict = dict(list(value.items())[:20])
+            sanitized[key] = _sanitize_error_context(truncated_dict)
+            sanitized[key]["__truncated__"] = True
+        else:
+            sanitized[key] = value
+    
+    return sanitized
+
+
+# Async exception handling utilities for MCP tools
+async def safe_execute_async(
+    coro: Any,
+    default_return: Any = None,
+    exception_types: tuple[type[Exception], ...] = (Exception,),
+    log_errors: bool = True,
+    tool_name: str | None = None,
+) -> Any:
+    """
+    Safely execute an async function with exception handling.
+    
+    Args:
+        coro: Coroutine to execute
+        default_return: Value to return on exception
+        exception_types: Exception types to catch
+        log_errors: Whether to log errors
+        tool_name: Name of the tool for error context
+    
+    Returns:
+        Coroutine result or default_return on exception
+    """
+    try:
+        return await coro
+    except exception_types as e:
+        if log_errors:
+            from .utils import log_error
+            
+            error_context = {"tool_name": tool_name} if tool_name else {}
+            log_error(f"Async execution failed: {e}", extra=error_context)
+        
+        return default_return
+
+
+def mcp_exception_handler(
+    tool_name: str,
+    include_debug: bool = False,
+    sanitize_sensitive: bool = True,
+) -> Any:
+    """
+    Decorator for MCP tool exception handling.
+    
+    Args:
+        tool_name: Name of the MCP tool
+        include_debug: Whether to include debug information
+        sanitize_sensitive: Whether to sanitize sensitive information
+    """
+    def decorator(func: Any) -> Any:
+        async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+            try:
+                return await func(*args, **kwargs)
+            except Exception as e:
+                from .utils import log_error
+                
+                # Log the error with tool context
+                log_error(
+                    f"MCP tool '{tool_name}' failed: {e}",
+                    extra={"tool_name": tool_name, "exception_type": type(e).__name__}
+                )
+                
+                # Return standardized error response
+                return create_mcp_error_response(
+                    e,
+                    tool_name=tool_name,
+                    include_debug_info=include_debug,
+                    sanitize_sensitive=sanitize_sensitive
+                )
+        
+        def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                from .utils import log_error
+                
+                # Log the error with tool context
+                log_error(
+                    f"MCP tool '{tool_name}' failed: {e}",
+                    extra={"tool_name": tool_name, "exception_type": type(e).__name__}
+                )
+                
+                # Return standardized error response
+                return create_mcp_error_response(
+                    e,
+                    tool_name=tool_name,
+                    include_debug_info=include_debug,
+                    sanitize_sensitive=sanitize_sensitive
+                )
+        
+        # Return appropriate wrapper based on function type
+        if __import__("asyncio").iscoroutinefunction(func):
+            return async_wrapper
+        else:
+            return sync_wrapper
+    
+    return decorator

tree_sitter_analyzer/file_handler.py

@@ -8,7 +8,22 @@ This module provides file reading functionality with encoding detection and fall
 from pathlib import Path
 
 from .encoding_utils import read_file_safe
-from .utils import log_error, log_info, log_warning
+from .utils import setup_logger
+
+# Set up logger for this module
+logger = setup_logger(__name__)
+
+def log_error(message: str, *args, **kwargs) -> None:
+    """Log error message"""
+    logger.error(message, *args, **kwargs)
+
+def log_info(message: str, *args, **kwargs) -> None:
+    """Log info message"""
+    logger.info(message, *args, **kwargs)
+
+def log_warning(message: str, *args, **kwargs) -> None:
+    """Log warning message"""
+    logger.warning(message, *args, **kwargs)
 
 
 def detect_language_from_extension(file_path: str) -> str:

tree_sitter_analyzer/interfaces/mcp_server.py

@@ -12,6 +12,8 @@ import logging
 import sys
 from typing import Any
 
+from .. import __version__
+
 try:
     from mcp.server import Server
     from mcp.server.models import InitializationOptions
@@ -68,7 +70,7 @@ class TreeSitterAnalyzerMCPServer:
 
         self.server: Server | None = None
         self.name = "tree-sitter-analyzer"
-        self.version = "2.0.0"
+        self.version = __version__
 
         log_info(f"Initializing {self.name} v{self.version}")
 

tree_sitter_analyzer/language_detector.py

@@ -66,6 +66,10 @@ class LanguageDetector:
         ".mkd": "markdown",
         ".mkdn": "markdown",
         ".mdx": "markdown",
+        # JSON系
+        ".json": "json",
+        ".jsonc": "json",
+        ".json5": "json",
     }
 
     # Ambiguous extensions (map to multiple languages)
@@ -100,6 +104,7 @@ class LanguageDetector:
         "rust",
         "go",
         "markdown",
+        "json",
     }
 
     def __init__(self) -> None:
@@ -143,6 +148,10 @@ class LanguageDetector:
             ".mkd": ("markdown", 0.8),
             ".mkdn": ("markdown", 0.8),
             ".mdx": ("markdown", 0.7),  # MDX might be mixed with JSX
+            # JSON extensions
+            ".json": ("json", 0.9),
+            ".jsonc": ("json", 0.8),  # JSON with comments
+            ".json5": ("json", 0.8),  # JSON5 format
         }
 
         # Content-based detection patterns
@@ -412,7 +421,9 @@ def detect_language_from_file(file_path: str) -> str:
     Returns:
         Detected language name
     """
-    return detector.detect_from_extension(file_path)
+    # Create a fresh instance to ensure latest configuration
+    fresh_detector = LanguageDetector()
+    return fresh_detector.detect_from_extension(file_path)
 
 
 def is_language_supported(language: str) -> bool:

tree_sitter_analyzer/mcp/tools/analyze_scale_tool.py

@@ -379,19 +379,27 @@ class AnalyzeScaleTool(BaseMCPTool):
         include_details = arguments.get("include_details", False)
         include_guidance = arguments.get("include_guidance", True)
 
+        # Security validation BEFORE path resolution to catch symlinks
+        is_valid, error_msg = self.security_validator.validate_file_path(file_path)
+        if not is_valid:
+            logger.warning(
+                f"Security validation failed for file path: {file_path} - {error_msg}"
+            )
+            raise ValueError(f"Invalid file path: {error_msg}")
+
         # 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
+        # Additional security validation on 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: {resolved_file_path} - {error_msg}"
+                f"Security validation failed for resolved path: {resolved_file_path} - {error_msg}"
             )
-            raise ValueError(f"Invalid file path: {error_msg}")
+            raise ValueError(f"Invalid resolved path: {error_msg}")
 
         # Sanitize inputs
         if language:
@@ -423,6 +431,12 @@ class AnalyzeScaleTool(BaseMCPTool):
                 # Calculate basic file metrics
                 file_metrics = self._calculate_file_metrics(resolved_file_path)
 
+                # Handle JSON files specially - they don't need structural analysis
+                if language == "json":
+                    return self._create_json_file_analysis(
+                        resolved_file_path, file_metrics, include_guidance
+                    )
+
                 # Use appropriate analyzer based on language
                 if language == "java":
                     # Use AdvancedAnalyzer for comprehensive analysis
@@ -472,6 +486,7 @@ class AnalyzeScaleTool(BaseMCPTool):
 
                 # Build enhanced result structure
                 result = {
+                    "success": True,
                     "file_path": file_path,
                     "language": language,
                     "file_metrics": file_metrics,
@@ -688,6 +703,56 @@ class AnalyzeScaleTool(BaseMCPTool):
 
         return True
 
+    def _create_json_file_analysis(
+        self, file_path: str, file_metrics: dict[str, Any], include_guidance: bool
+    ) -> dict[str, Any]:
+        """
+        Create analysis result for JSON files.
+        
+        Args:
+            file_path: Path to the JSON file
+            file_metrics: Basic file metrics
+            include_guidance: Whether to include guidance
+            
+        Returns:
+            Analysis result for JSON file
+        """
+        result = {
+            "success": True,
+            "file_path": file_path,
+            "language": "json",
+            "file_size_bytes": file_metrics["file_size_bytes"],
+            "total_lines": file_metrics["total_lines"],
+            "non_empty_lines": file_metrics["total_lines"] - file_metrics["blank_lines"],
+            "estimated_tokens": file_metrics["estimated_tokens"],
+            "complexity_metrics": {
+                "total_elements": 0,
+                "max_depth": 0,
+                "avg_complexity": 0.0,
+            },
+            "structural_overview": {
+                "classes": [],
+                "methods": [],
+                "fields": [],
+            },
+            "scale_category": "small" if file_metrics["total_lines"] < 100 else "medium" if file_metrics["total_lines"] < 1000 else "large",
+            "analysis_recommendations": {
+                "suitable_for_full_analysis": file_metrics["total_lines"] < 1000,
+                "recommended_approach": "JSON files are configuration/data files - structural analysis not applicable",
+                "token_efficiency_notes": "JSON files can be read directly without tree-sitter parsing",
+            },
+        }
+        
+        if include_guidance:
+            result["llm_analysis_guidance"] = {
+                "file_characteristics": "JSON configuration/data file",
+                "recommended_workflow": "Direct file reading for content analysis",
+                "token_optimization": "Use simple file reading tools for JSON content",
+                "analysis_focus": "Data structure and configuration values",
+            }
+            
+        return result
+
     def get_tool_definition(self) -> dict[str, Any]:
         """
         Get the MCP tool definition for check_code_scale.

tree_sitter_analyzer/mcp/tools/fd_rg_utils.py

@@ -11,6 +11,7 @@ from __future__ import annotations
 import asyncio
 import json
 import os
+import shutil
 import tempfile
 from dataclasses import dataclass
 from pathlib import Path
@@ -27,6 +28,21 @@ DEFAULT_RG_TIMEOUT_MS = 4000
 RG_TIMEOUT_HARD_CAP_MS = 30000
 
 
+def check_external_command(command: str) -> bool:
+    """Check if an external command is available in the system PATH."""
+    return shutil.which(command) is not None
+
+
+def get_missing_commands() -> list[str]:
+    """Get list of missing external commands required by fd/rg tools."""
+    missing = []
+    if not check_external_command("fd"):
+        missing.append("fd")
+    if not check_external_command("rg"):
+        missing.append("rg")
+    return missing
+
+
 def clamp_int(value: int | None, default_value: int, hard_cap: int) -> int:
     if value is None:
         return default_value
@@ -64,13 +80,22 @@ async def run_command_capture(
     Returns (returncode, stdout, stderr). On timeout, kills process and returns 124.
     Separated into a util for easy monkeypatching in tests.
     """
-    # Create process
-    proc = await asyncio.create_subprocess_exec(
-        *cmd,
-        stdin=asyncio.subprocess.PIPE if input_data is not None else None,
-        stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE,
-    )
+    # Check if command exists before attempting to run
+    if cmd and not check_external_command(cmd[0]):
+        error_msg = f"Command '{cmd[0]}' not found in PATH. Please install {cmd[0]} to use this functionality."
+        return 127, b"", error_msg.encode()
+    
+    try:
+        # Create process
+        proc = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdin=asyncio.subprocess.PIPE if input_data is not None else None,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+    except FileNotFoundError as e:
+        error_msg = f"Command '{cmd[0]}' not found: {e}"
+        return 127, b"", error_msg.encode()
 
     # Compute timeout seconds
     timeout_s: float | None = None

tree_sitter_analyzer/mcp/tools/find_and_grep_tool.py

@@ -239,6 +239,16 @@ class FindAndGrepTool(BaseMCPTool):
 
     @handle_mcp_errors("find_and_grep")
     async def execute(self, arguments: dict[str, Any]) -> dict[str, Any]:
+        # Check if both fd and rg commands are available
+        missing_commands = fd_rg_utils.get_missing_commands()
+        if missing_commands:
+            return {
+                "success": False,
+                "error": f"Required commands not found: {', '.join(missing_commands)}. Please install fd (https://github.com/sharkdp/fd) and ripgrep (https://github.com/BurntSushi/ripgrep) to use this tool.",
+                "count": 0,
+                "results": []
+            }
+        
         self.validate_arguments(arguments)
         roots = self._validate_roots(arguments["roots"])  # absolute validated
 

tree_sitter_analyzer/mcp/tools/list_files_tool.py

@@ -181,6 +181,15 @@ class ListFilesTool(BaseMCPTool):
 
     @handle_mcp_errors("list_files")
     async def execute(self, arguments: dict[str, Any]) -> dict[str, Any]:
+        # Check if fd command is available
+        if not fd_rg_utils.check_external_command("fd"):
+            return {
+                "success": False,
+                "error": "fd command not found. Please install fd (https://github.com/sharkdp/fd) to use this tool.",
+                "count": 0,
+                "results": []
+            }
+        
         self.validate_arguments(arguments)
         roots = self._validate_roots(arguments["roots"])  # normalized absolutes
 

tree_sitter_analyzer/mcp/tools/query_tool.py

@@ -113,17 +113,24 @@ class QueryTool(BaseMCPTool):
         if not file_path:
             raise ValueError("file_path is required")
 
+        # Security validation BEFORE path resolution to catch symlinks
+        is_valid, error_msg = self.security_validator.validate_file_path(file_path)
+        if not is_valid:
+            raise ValueError(
+                f"Invalid or unsafe file path: {error_msg or 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
+        # Additional security validation on 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}"
+                f"Invalid or unsafe resolved path: {error_msg or resolved_file_path}"
             )
 
         # Get query parameters

tree_sitter_analyzer/mcp/tools/read_partial_tool.py

@@ -116,34 +116,70 @@ class ReadPartialTool(BaseMCPTool):
         suppress_output = arguments.get("suppress_output", False)
         output_format = arguments.get("format", "text")
 
+        # Security validation BEFORE path resolution to catch symlinks
+        is_valid, error_msg = self.security_validator.validate_file_path(file_path, self.project_root)
+        if not is_valid:
+            logger.warning(
+                f"Security validation failed for file path: {file_path} - {error_msg}"
+            )
+            return {
+                "success": False,
+                "error": f"Security validation failed: {error_msg}",
+                "file_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)
+        # Additional security validation on resolved path
+        is_valid, error_msg = self.security_validator.validate_file_path(resolved_path, self.project_root)
         if not is_valid:
             logger.warning(
-                f"Security validation failed for file path: {file_path} - {error_msg}"
+                f"Security validation failed for resolved path: {resolved_path} - {error_msg}"
             )
-            raise ValueError(f"Invalid file path: {error_msg}")
+            return {
+                "success": False,
+                "error": f"Security validation failed for resolved path: {error_msg}",
+                "file_path": file_path
+            }
 
         # Validate file exists
         if not Path(resolved_path).exists():
-            raise ValueError("Invalid file path: file does not exist")
+            return {
+                "success": False,
+                "error": "Invalid file path: file does not exist",
+                "file_path": file_path
+            }
 
         # Validate line numbers
         if start_line < 1:
-            raise ValueError("start_line must be >= 1")
+            return {
+                "success": False,
+                "error": "start_line must be >= 1",
+                "file_path": file_path
+            }
 
         if end_line is not None and end_line < start_line:
-            raise ValueError("end_line must be >= start_line")
+            return {
+                "success": False,
+                "error": "end_line must be >= start_line",
+                "file_path": file_path
+            }
 
         # Validate column numbers
         if start_column is not None and start_column < 0:
-            raise ValueError("start_column must be >= 0")
+            return {
+                "success": False,
+                "error": "start_column must be >= 0",
+                "file_path": file_path
+            }
 
         if end_column is not None and end_column < 0:
-            raise ValueError("end_column must be >= 0")
+            return {
+                "success": False,
+                "error": "end_column must be >= 0",
+                "file_path": file_path
+            }
 
         logger.info(
             f"Reading partial content from {file_path}: lines {start_line}-{end_line or 'end'}"
@@ -160,9 +196,19 @@ class ReadPartialTool(BaseMCPTool):
                 )
 
                 if content is None:
-                    raise RuntimeError(
-                        f"Failed to read partial content from file: {file_path}"
-                    )
+                    return {
+                        "success": False,
+                        "error": f"Failed to read partial content from file: {file_path}",
+                        "file_path": file_path
+                    }
+                
+                # Check if content is empty or invalid range
+                if not content or content.strip() == "":
+                    return {
+                        "success": False,
+                        "error": f"Invalid line range or empty content: start_line={start_line}, end_line={end_line}",
+                        "file_path": file_path
+                    }
 
                 # Build result structure compatible with CLI --partial-read format
                 result_data = {
@@ -198,8 +244,14 @@ class ReadPartialTool(BaseMCPTool):
                     f"Successfully read {len(content)} characters from {file_path}"
                 )
 
+                # Calculate lines extracted
+                lines_extracted = len(content.split('\n')) if content else 0
+                if end_line:
+                    lines_extracted = end_line - start_line + 1
+
                 # Build result - conditionally include partial_content_result based on suppress_output
                 result = {
+                    "success": True,
                     "file_path": file_path,
                     "range": {
                         "start_line": start_line,
@@ -208,11 +260,39 @@ class ReadPartialTool(BaseMCPTool):
                         "end_column": end_column,
                     },
                     "content_length": len(content),
+                    "lines_extracted": lines_extracted,
                 }
 
                 # Only include partial_content_result if not suppressed or no output file specified
                 if not suppress_output or not output_file:
-                    result["partial_content_result"] = cli_output
+                    if output_format == "json":
+                        # For JSON format, return structured data with exact line count
+                        lines = content.split('\n') if content else []
+                        
+                        # If end_line is specified, ensure we return exactly the requested number of lines
+                        if end_line and len(lines) > lines_extracted:
+                            lines = lines[:lines_extracted]
+                        elif end_line and len(lines) < lines_extracted:
+                            # Pad with empty lines if needed (shouldn't normally happen)
+                            lines.extend([''] * (lines_extracted - len(lines)))
+                        
+                        result["partial_content_result"] = {
+                            "lines": lines,
+                            "metadata": {
+                                "file_path": file_path,
+                                "range": {
+                                    "start_line": start_line,
+                                    "end_line": end_line,
+                                    "start_column": start_column,
+                                    "end_column": end_column,
+                                },
+                                "content_length": len(content),
+                                "lines_count": len(lines)
+                            }
+                        }
+                    else:
+                        # For text/raw format, return CLI-compatible string
+                        result["partial_content_result"] = cli_output
 
                 # Handle file output if requested
                 if output_file:
@@ -254,7 +334,11 @@ class ReadPartialTool(BaseMCPTool):
 
         except Exception as e:
             logger.error(f"Error reading partial content from {file_path}: {e}")
-            raise
+            return {
+                "success": False,
+                "error": str(e),
+                "file_path": file_path
+            }
 
     def _read_file_partial(
         self,

tree_sitter_analyzer/mcp/tools/search_content_tool.py

@@ -289,6 +289,15 @@ class SearchContentTool(BaseMCPTool):
 
     @handle_mcp_errors("search_content")
     async def execute(self, arguments: dict[str, Any]) -> dict[str, Any] | int:
+        # Check if rg command is available
+        if not fd_rg_utils.check_external_command("rg"):
+            return {
+                "success": False,
+                "error": "rg (ripgrep) command not found. Please install ripgrep (https://github.com/BurntSushi/ripgrep) to use this tool.",
+                "count": 0,
+                "results": []
+            }
+        
         self.validate_arguments(arguments)
 
         roots = arguments.get("roots")

tree_sitter_analyzer/mcp/tools/table_format_tool.py

@@ -242,6 +242,7 @@ class TableFormatTool(BaseMCPTool):
             package_info = {"name": packages[0].name}
 
         return {
+            "success": True,
             "file_path": result.file_path,
             "language": result.language,
             "package": package_info,
@@ -378,18 +379,26 @@ class TableFormatTool(BaseMCPTool):
             output_file = args.get("output_file")
             suppress_output = args.get("suppress_output", False)
 
+            # Security validation BEFORE path resolution to catch symlinks
+            is_valid, error_msg = self.security_validator.validate_file_path(file_path)
+            if not is_valid:
+                self.logger.warning(
+                    f"Security validation failed for file path: {file_path} - {error_msg}"
+                )
+                raise ValueError(f"Invalid file path: {error_msg}")
+
             # Resolve file path using common path resolver
             resolved_path = self.path_resolver.resolve(file_path)
 
-            # Security validation
+            # Additional security validation on resolved path
             is_valid, error_msg = self.security_validator.validate_file_path(
                 resolved_path
             )
             if not is_valid:
                 self.logger.warning(
-                    f"Security validation failed for file path: {file_path} - {error_msg}"
+                    f"Security validation failed for resolved path: {resolved_path} - {error_msg}"
                 )
-                raise ValueError(f"Invalid file path: {error_msg}")
+                raise ValueError(f"Invalid resolved path: {error_msg}")
 
             # Sanitize format_type input
             if format_type:
@@ -470,6 +479,7 @@ class TableFormatTool(BaseMCPTool):
 
                 # Build result - conditionally include table_output based on suppress_output
                 result = {
+                    "success": True,
                     "format_type": format_type,
                     "file_path": file_path,
                     "language": language,

tree_sitter_analyzer/security/validator.py

@@ -100,12 +100,13 @@ class SecurityValidator:
 
             # Layer 4: Absolute path check (cross-platform)
             if Path(file_path).is_absolute() or file_path.startswith(("/", "\\")):
+                log_debug(f"Processing absolute path: {file_path}")
                 # If project boundaries are configured, enforce them strictly
                 if self.boundary_manager and self.boundary_manager.project_root:
                     if not self.boundary_manager.is_within_project(file_path):
                         return False, "Absolute path must be within project directory"
-                    # Within project
-                    return True, ""
+                    # Within project - continue with symlink checks
+                    log_debug("Absolute path is within project, continuing with symlink checks")
                 else:
                     # In test/dev contexts without project boundaries, allow absolute
                     # paths under system temp folder only (safe sandbox)
@@ -113,12 +114,13 @@ class SecurityValidator:
 
                     temp_dir = Path(tempfile.gettempdir()).resolve()
                     real_path = Path(file_path).resolve()
+                    log_debug(f"Checking if {real_path} is under temp dir {temp_dir}")
                     try:
                         real_path.relative_to(temp_dir)
-                        return True, ""
+                        log_debug("Path is under temp directory, continuing with symlink checks")
+                        # Don't return here - continue with symlink checks
                     except ValueError:
-                        pass
-                    return False, "Absolute file paths are not allowed"
+                        return False, "Absolute file paths are not allowed"
 
             # Layer 5: Path normalization and traversal check
             norm_path = str(Path(file_path))
@@ -136,12 +138,69 @@ class SecurityValidator:
                         "Access denied. File path must be within project directory",
                     )
 
-            # Layer 7: Symbolic link check (if file exists)
+            # Layer 7: Symbolic link and junction check (check both original and resolved paths)
+            # First check the original file_path directly for symlinks and junctions
+            try:
+                original_path = Path(file_path)
+                log_debug(f"Checking symlink status for original path: {original_path}")
+                # Check for symlinks even if the file doesn't exist yet (broken symlinks)
+                is_symlink = original_path.is_symlink()
+                log_debug(f"original_path.is_symlink() = {is_symlink}")
+                if is_symlink:
+                    log_warning(f"Symbolic link detected in original path: {original_path}")
+                    return False, "Symbolic links are not allowed"
+                
+                # Additional check for Windows junctions and reparse points (only if exists)
+                if original_path.exists() and self._is_junction_or_reparse_point(original_path):
+                    log_warning(f"Junction or reparse point detected in original path: {original_path}")
+                    return False, "Junctions and reparse points are not allowed"
+                    
+            except (OSError, PermissionError) as e:
+                # If we can't check symlink status, continue with other checks
+                log_debug(f"Exception checking symlink status: {e}")
+                pass
+            
+            # Then check the full path (base_path + norm_path) if base_path is provided
             if base_path:
                 full_path = Path(base_path) / norm_path
-                if full_path.exists() and full_path.is_symlink():
-                    log_warning(f"Symbolic link detected: {full_path}")
-                    return False, "Symbolic links are not allowed"
+                
+                # Check if the full path is a symlink or junction
+                try:
+                    # Check for symlinks even if the file doesn't exist yet (broken symlinks)
+                    if full_path.is_symlink():
+                        log_warning(f"Symbolic link detected: {full_path}")
+                        return False, "Symbolic links are not allowed"
+                    
+                    # Additional check for Windows junctions and reparse points (only if exists)
+                    if full_path.exists() and self._is_junction_or_reparse_point(full_path):
+                        log_warning(f"Junction or reparse point detected: {full_path}")
+                        return False, "Junctions and reparse points are not allowed"
+                        
+                except (OSError, PermissionError):
+                    # If we can't check symlink status due to permissions, be cautious
+                    log_warning(f"Cannot verify symlink status for: {full_path}")
+                    pass
+                
+                # Check parent directories for junctions (Windows-specific security measure)
+                try:
+                    if self._has_junction_in_path(full_path):
+                        log_warning(f"Junction detected in path hierarchy: {full_path}")
+                        return False, "Paths containing junctions are not allowed"
+                except (OSError, PermissionError):
+                    # If we can't check parent directories, continue
+                    pass
+            else:
+                # For absolute paths or when no base_path is provided, use original_path
+                full_path = original_path
+                
+                # Check parent directories for junctions
+                try:
+                    if self._has_junction_in_path(full_path):
+                        log_warning(f"Junction detected in path hierarchy: {full_path}")
+                        return False, "Paths containing junctions are not allowed"
+                except (OSError, PermissionError):
+                    # If we can't check parent directories, continue
+                    pass
 
             log_debug(f"File path validation passed: {file_path}")
             return True, ""
@@ -268,3 +327,103 @@ class SecurityValidator:
         except Exception as e:
             log_warning(f"Glob pattern validation error: {e}")
             return False, f"Validation error: {str(e)}"
+
+    def validate_path(self, path: str, base_path: str | None = None) -> tuple[bool, str]:
+        """
+        Alias for validate_file_path for backward compatibility.
+        
+        Args:
+            path: Path to validate
+            base_path: Optional base path for relative path validation
+            
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        return self.validate_file_path(path, base_path)
+
+    def is_safe_path(self, path: str, base_path: str | None = None) -> bool:
+        """
+        Check if a path is safe (backward compatibility method).
+        
+        Args:
+            path: Path to check
+            base_path: Optional base path for relative path validation
+            
+        Returns:
+            True if path is safe, False otherwise
+        """
+        is_valid, _ = self.validate_file_path(path, base_path)
+        return is_valid
+
+    def _is_junction_or_reparse_point(self, path: Path) -> bool:
+        """
+        Check if a path is a Windows junction or reparse point.
+        
+        Args:
+            path: Path to check
+            
+        Returns:
+            True if the path is a junction or reparse point
+        """
+        try:
+            import platform
+            if platform.system() != "Windows":
+                return False
+                
+            # On Windows, check for reparse points using stat
+            import stat
+            if path.exists():
+                path_stat = path.stat()
+                # Check if it has the reparse point attribute
+                if hasattr(stat, 'FILE_ATTRIBUTE_REPARSE_POINT'):
+                    return bool(path_stat.st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT)
+                
+            # Alternative method using Windows API
+            try:
+                import ctypes
+                from ctypes import wintypes
+                
+                # GetFileAttributesW function
+                _GetFileAttributesW = ctypes.windll.kernel32.GetFileAttributesW
+                _GetFileAttributesW.argtypes = [wintypes.LPCWSTR]
+                _GetFileAttributesW.restype = wintypes.DWORD
+                
+                FILE_ATTRIBUTE_REPARSE_POINT = 0x400
+                INVALID_FILE_ATTRIBUTES = 0xFFFFFFFF
+                
+                attributes = _GetFileAttributesW(str(path))
+                if attributes != INVALID_FILE_ATTRIBUTES:
+                    return bool(attributes & FILE_ATTRIBUTE_REPARSE_POINT)
+                    
+            except (ImportError, AttributeError, OSError):
+                pass
+                
+        except Exception:
+            # If any error occurs, assume it's not a junction for safety
+            pass
+            
+        return False
+
+    def _has_junction_in_path(self, path: Path) -> bool:
+        """
+        Check if any parent directory in the path is a junction.
+        
+        Args:
+            path: Path to check
+            
+        Returns:
+            True if any parent directory is a junction
+        """
+        try:
+            current_path = path.resolve() if path.exists() else path
+            
+            # Check each parent directory
+            for parent in current_path.parents:
+                if self._is_junction_or_reparse_point(parent):
+                    return True
+                    
+        except Exception:
+            # If any error occurs, assume no junctions for safety
+            pass
+            
+        return False

{tree_sitter_analyzer-1.7.5.dist-info → tree_sitter_analyzer-1.7.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tree-sitter-analyzer
-Version: 1.7.5
+Version: 1.7.7
 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
@@ -34,6 +34,7 @@ Requires-Python: >=3.10
 Requires-Dist: cachetools>=5.0.0
 Requires-Dist: chardet>=5.0.0
 Requires-Dist: mcp>=1.12.3
+Requires-Dist: psutil>=5.9.8
 Requires-Dist: tree-sitter-cpp<0.25.0,>=0.23.4
 Requires-Dist: tree-sitter-java<0.25.0,>=0.23.5
 Requires-Dist: tree-sitter-javascript<0.25.0,>=0.23.1
@@ -123,6 +124,21 @@ Requires-Dist: tree-sitter-typescript<0.25.0,>=0.20.0; extra == 'full'
 Requires-Dist: types-psutil>=5.9.0; extra == 'full'
 Provides-Extra: go
 Requires-Dist: tree-sitter-go<0.25.0,>=0.20.0; extra == 'go'
+Provides-Extra: integration
+Requires-Dist: anyio>=4.0.0; extra == 'integration'
+Requires-Dist: mcp>=1.12.2; extra == 'integration'
+Requires-Dist: memory-profiler>=0.61.0; extra == 'integration'
+Requires-Dist: psutil>=5.9.8; extra == 'integration'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'integration'
+Requires-Dist: pytest-benchmark>=4.0.0; extra == 'integration'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'integration'
+Requires-Dist: pytest-mock>=3.14.1; extra == 'integration'
+Requires-Dist: pytest>=8.4.1; extra == 'integration'
+Requires-Dist: tree-sitter-java>=0.23.5; extra == 'integration'
+Requires-Dist: tree-sitter-javascript>=0.23.1; extra == 'integration'
+Requires-Dist: tree-sitter-markdown>=0.3.1; extra == 'integration'
+Requires-Dist: tree-sitter-python>=0.23.0; extra == 'integration'
+Requires-Dist: tree-sitter-typescript>=0.20.0; extra == 'integration'
 Provides-Extra: java
 Requires-Dist: tree-sitter-java<0.25.0,>=0.23.5; extra == 'java'
 Provides-Extra: javascript
@@ -171,7 +187,7 @@ 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-2934%20passed-brightgreen.svg)](#quality-assurance)
+[![Tests](https://img.shields.io/badge/tests-3088%20passed-brightgreen.svg)](#quality-assurance)
 [![Coverage](https://codecov.io/gh/aimasteracc/tree-sitter-analyzer/branch/main/graph/badge.svg)](https://codecov.io/gh/aimasteracc/tree-sitter-analyzer)
 [![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/)
@@ -226,7 +242,7 @@ Tree-sitter Analyzer is an enterprise-grade code analysis tool designed for the
 | **Go** | Basic Support | Basic syntax parsing |
 
 ### 🏆 Production Ready
-- **2,934 Tests** - 100% pass rate, enterprise-grade quality assurance
+- **3,088 Tests** - 100% pass rate, enterprise-grade quality assurance
 - **High Coverage** - Comprehensive test coverage
 - **Cross-platform Support** - Compatible with Windows, macOS, Linux
 - **Continuous Maintenance** - Active development and community support
@@ -737,13 +753,13 @@ uv run python -m tree_sitter_analyzer --show-query-languages
 ## 8. 🏆 Quality Assurance
 
 ### 📊 Quality Metrics
-- **2,934 tests** - 100% pass rate ✅
+- **3,088 tests** - 100% pass rate ✅
 - **High code coverage** - Comprehensive test suite
 - **Zero test failures** - Production ready
 - **Cross-platform support** - Windows, macOS, Linux
 
 ### ⚡ Latest Quality Achievements (v1.7.5)
-- ✅ **📊 Enhanced Quality Metrics** - Test count increased to 2,934, coverage maintained at high levels
+- ✅ **📊 Enhanced Quality Metrics** - Test count increased to 3,088 coverage maintained at high levels
 - ✅ **🔧 System Stability** - All tests passing with enhanced system stability and reliability
 - ✅ **🆕 Complete Markdown Support** - Added new complete Markdown language plugin supporting all major Markdown elements
 - ✅ **📝 Enhanced Document Analysis** - Support for intelligent extraction of headers, code blocks, links, images, tables, task lists

{tree_sitter_analyzer-1.7.5.dist-info → tree_sitter_analyzer-1.7.7.dist-info}/RECORD

@@ -1,12 +1,12 @@
-tree_sitter_analyzer/__init__.py,sha256=pwmo3OAgET_ifX0qH_OG7f8YXyg4Xp2DLDEIGR3rs3k,3067
+tree_sitter_analyzer/__init__.py,sha256=xWap73ImPJpNVKE4Ilozpzocq52xSK3vtvVDYU3W2kI,3067
 tree_sitter_analyzer/__main__.py,sha256=Zl79tpe4UaMu-7yeztc06tgP0CVMRnvGgas4ZQP5SCs,228
-tree_sitter_analyzer/api.py,sha256=jzwID6fJNdhQkJP3D0lzBVPhOnGIN4tyyMtmRYdK9zI,22753
+tree_sitter_analyzer/api.py,sha256=BzH-0MmK7qoNvsTAmLovFq3E_50ci0CoozzYXJdn3cQ,22759
 tree_sitter_analyzer/cli_main.py,sha256=BuaM-L-Jx3G49qvAUOQVsw0wEM-X0UzPaRszRZBist4,10374
 tree_sitter_analyzer/constants.py,sha256=7w3sLFt_6vPaKsxzrc21K1rOKpLGMyyA1203nu3pDOQ,1889
 tree_sitter_analyzer/encoding_utils.py,sha256=BgdBKnW20EueEFJT-aLrQI38bTOcR5rWQ3Dpa-ALszA,14805
-tree_sitter_analyzer/exceptions.py,sha256=AZryCQyKXekAg8lQZd3zqULnjhCKovBNNpnUlNGDhcI,11615
-tree_sitter_analyzer/file_handler.py,sha256=mtWz-DE4yfmak347s0e20xFNy3qddcek58Enom5GlZQ,6689
-tree_sitter_analyzer/language_detector.py,sha256=MoGDGqKREBd3GMPJ7QoQCdBmTloWskC5plnjNfDuEO0,12957
+tree_sitter_analyzer/exceptions.py,sha256=XvuUYsB80JYcpfU3Lq0XXpmeV3aWK2tJ_nKNGJtILe4,23116
+tree_sitter_analyzer/file_handler.py,sha256=pyNro47kYoRuQBPkyEo9ileqlQ1A7w890deQltnzMas,7115
+tree_sitter_analyzer/language_detector.py,sha256=9vPer4Lr1tjNR_GMP-OyuLTIldgKszRRddvBVSt1x1E,13353
 tree_sitter_analyzer/language_loader.py,sha256=sIICLkht_PeVoYV1KTs5bSgOJej9xK9wbyRB2-0Agws,8966
 tree_sitter_analyzer/models.py,sha256=eZSVTl4s0rnqG21nyCTaJhyhDw1HZkkpMRKCi2QRkL0,20404
 tree_sitter_analyzer/output_manager.py,sha256=tMEyjGeczqphcLoHdqxgyW8KaG8w6JF-fhsIibNQiCU,8260
@@ -50,7 +50,7 @@ tree_sitter_analyzer/interfaces/__init__.py,sha256=OcT7eNIU0ZXvAeAXbhDqRG3puxn93
 tree_sitter_analyzer/interfaces/cli.py,sha256=c6CGfF6cgOwgpBimHV1myZ5JfNqil5tCVBOfG5-zijU,17100
 tree_sitter_analyzer/interfaces/cli_adapter.py,sha256=8j3xL3k6wWrGQCq0KCntqbvSxKy931sT5M96pYhkn9c,11402
 tree_sitter_analyzer/interfaces/mcp_adapter.py,sha256=iSWcm-bn8_pL6YBu1Rrzherv72-5WUiavColu3uhSAY,7707
-tree_sitter_analyzer/interfaces/mcp_server.py,sha256=dUFn1CyO2jLa_y5gGOGE-f0sLGAbjgp738uy5-aAphI,16510
+tree_sitter_analyzer/interfaces/mcp_server.py,sha256=SP0_X4pltjFTH5Mq0NouJbazkYijqjcsNvPegM3WtQE,16542
 tree_sitter_analyzer/languages/__init__.py,sha256=VTXxJgVjHJAciLhX0zzXOS4EygZMtebeYUbi_0z6fGw,340
 tree_sitter_analyzer/languages/java_plugin.py,sha256=SEGS-54gF2-kIv8ftYGqq_KNnwPXGw9XnSONlzowHWk,53191
 tree_sitter_analyzer/languages/javascript_plugin.py,sha256=2O6X5M1ZKQNdWoMmMJXHw5CEk2FxkPjR6wy3iHCyeak,57090
@@ -63,16 +63,16 @@ tree_sitter_analyzer/mcp/resources/__init__.py,sha256=D46ZDhPQaCrQze8dHmijMg1QZQ
 tree_sitter_analyzer/mcp/resources/code_file_resource.py,sha256=ZX5ZYSJfylBedpL80kTDlco2YZqgRMb5f3OW0VvOVRM,6166
 tree_sitter_analyzer/mcp/resources/project_stats_resource.py,sha256=YF_LyYwt1uoJx27FvWbVSbIaS5c5RDO-73QL_DfNwTE,20360
 tree_sitter_analyzer/mcp/tools/__init__.py,sha256=9KfetZTaUhvWTeKuZPYzWb7ZomFQ8SsR1qmXVBT4E7c,739
-tree_sitter_analyzer/mcp/tools/analyze_scale_tool.py,sha256=4ls3IuoePMwyYVNFpHznXuv0MZhVEJV0cNKnnz5zTUo,28087
+tree_sitter_analyzer/mcp/tools/analyze_scale_tool.py,sha256=Yb9lpUPGuvRbawmE15icMRW1yn9BVp6kSXb0iZqaTGY,30920
 tree_sitter_analyzer/mcp/tools/analyze_scale_tool_cli_compatible.py,sha256=mssed7bEfGeGxW4mOf7dg8BDS1oqHLolIBNX9DaZ3DM,8997
 tree_sitter_analyzer/mcp/tools/base_tool.py,sha256=qf2My325azlnKOugNVMN_R1jtZcjXVy354sGVKzvZls,3546
-tree_sitter_analyzer/mcp/tools/fd_rg_utils.py,sha256=R1ICH40vkWO3OdKZjxok9ptQZpZ6-tM5SkLHHOC4-BE,17749
-tree_sitter_analyzer/mcp/tools/find_and_grep_tool.py,sha256=uoa0DiX0-M79RYkgq-_HWeJVQUaJpRvE0a1nZLT7Js0,31130
-tree_sitter_analyzer/mcp/tools/list_files_tool.py,sha256=atLpBIngGYhmO3hpfujiIz37ng2_Gop1ocEVaV4bs08,17914
-tree_sitter_analyzer/mcp/tools/query_tool.py,sha256=yGtivYOdV9AgOd-FkvQY-laiFiw-2TgZgoel6r25xuY,15057
-tree_sitter_analyzer/mcp/tools/read_partial_tool.py,sha256=KFmcCJxn1t-IN7Lf9DzbRK2FXytFSFBCPJ9h_mYd9dI,14868
-tree_sitter_analyzer/mcp/tools/search_content_tool.py,sha256=WilpA-bOko31aj8lI73luCHoKfTB623vG8tClBowO3Y,32086
-tree_sitter_analyzer/mcp/tools/table_format_tool.py,sha256=r7mJMRypBtjcZhKoo7fijt3RW11QbrQy8tWjoMzeWfM,20885
+tree_sitter_analyzer/mcp/tools/fd_rg_utils.py,sha256=9jQ4D5yREs7Nt8L0s-NdVtmaKXJAAOKqAAI8mkW3T2o,18664
+tree_sitter_analyzer/mcp/tools/find_and_grep_tool.py,sha256=9p_Olh6wjuUAVqHfXnsUj3crZtUV4_R6zAfKRqe8jTY,31623
+tree_sitter_analyzer/mcp/tools/list_files_tool.py,sha256=nd6uiOqbsr8NUqNL46d8QnOM-XpMTDOFiaccjBaGLl8,18268
+tree_sitter_analyzer/mcp/tools/query_tool.py,sha256=25k7AHYH4gzhu2XQ5CetBDXDTd_nLdXcEIKmDi6jj04,15367
+tree_sitter_analyzer/mcp/tools/read_partial_tool.py,sha256=lC3Zigp3_v8RU_fi5Fz0O_idjP6z_AmgoqVQOethL3I,18493
+tree_sitter_analyzer/mcp/tools/search_content_tool.py,sha256=wGYjP5OZqqcKnLwF5sdpH3xMuUaxJmwYWU6Rg3R7CAw,32463
+tree_sitter_analyzer/mcp/tools/table_format_tool.py,sha256=gmLqWwFJC63YuyHyMsmCtm-tki1bzeHFvGPIHQTjhig,21398
 tree_sitter_analyzer/mcp/tools/universal_analyze_tool.py,sha256=-zZnqN9WcoyRTKM_16ADH859LSebzi34BGYwQL2zCOs,25084
 tree_sitter_analyzer/mcp/utils/__init__.py,sha256=TgTTKsRJAqF95g1fAp5SR_zQVDkImpc_5R0Dw529UUw,3126
 tree_sitter_analyzer/mcp/utils/error_handler.py,sha256=msrQHX67K3vhJsEc3OPRz5mmWU_yoHz55Lnxy0IZuy4,18404
@@ -92,8 +92,8 @@ tree_sitter_analyzer/queries/typescript.py,sha256=I0bWcCv-sRcZHVsdHdfb1UIRI_G3l0
 tree_sitter_analyzer/security/__init__.py,sha256=ZTqTt24hsljCpTXAZpJC57L7MU5lJLTf_XnlvEzXwEE,623
 tree_sitter_analyzer/security/boundary_manager.py,sha256=3eeENRKWtz2pyZHzd8DiVaq8fdeC6s1eVOuBylSmQPg,9347
 tree_sitter_analyzer/security/regex_checker.py,sha256=jWK6H8PTPgzbwRPfK_RZ8bBTS6rtEbgjY5vr3YWjQ_U,9616
-tree_sitter_analyzer/security/validator.py,sha256=yR4qTWEcXpR--bSFwtWvSgY0AzqujOFAqlc1Z7dlTdk,9809
-tree_sitter_analyzer-1.7.5.dist-info/METADATA,sha256=KOVhKnK9yXkpDYM_EKNM4tbUYVGkBZBQu0T6A4GKMLY,40685
-tree_sitter_analyzer-1.7.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-tree_sitter_analyzer-1.7.5.dist-info/entry_points.txt,sha256=TOW_FpPd7qg0Uq0f44VItnO4HXPdYi7yJUjnQH-0fAM,853
-tree_sitter_analyzer-1.7.5.dist-info/RECORD,,
+tree_sitter_analyzer/security/validator.py,sha256=GLsb0TQLzx7mEQ5g-_lLXK8Zo-_r8EM9HtEQCh3vxrc,17037
+tree_sitter_analyzer-1.7.7.dist-info/METADATA,sha256=SEZZeToclVg4umS6VTTw_bNUwP-XC9mSf-MsaxMnlp4,41591
+tree_sitter_analyzer-1.7.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+tree_sitter_analyzer-1.7.7.dist-info/entry_points.txt,sha256=TOW_FpPd7qg0Uq0f44VItnO4HXPdYi7yJUjnQH-0fAM,853
+tree_sitter_analyzer-1.7.7.dist-info/RECORD,,