tree-sitter-analyzer 0.8.3__py3-none-any.whl → 0.9.1__py3-none-any.whl

tree_sitter_analyzer/security/validator.py

@@ -1,244 +1,241 @@
-#!/usr/bin/env python3
-"""
-Security Validator for Tree-sitter Analyzer
-
-Provides unified security validation framework inspired by code-index-mcp's
-ValidationHelper but enhanced for tree-sitter analyzer's requirements.
-"""
-
-import os
-import re
-from pathlib import Path
-from typing import Optional, Tuple
-
-from ..exceptions import SecurityError
-from ..utils import log_debug, log_warning
-from .boundary_manager import ProjectBoundaryManager
-from .regex_checker import RegexSafetyChecker
-
-
-class SecurityValidator:
-    """
-    Unified security validation framework.
-    
-    This class provides comprehensive security validation for file paths,
-    regex patterns, and other user inputs to prevent security vulnerabilities.
-    
-    Features:
-    - Multi-layer path traversal protection
-    - Project boundary enforcement
-    - ReDoS attack prevention
-    - Input sanitization
-    """
-
-    def __init__(self, project_root: Optional[str] = None) -> None:
-        """
-        Initialize security validator.
-        
-        Args:
-            project_root: Optional project root directory for boundary checks
-        """
-        self.boundary_manager = (
-            ProjectBoundaryManager(project_root) if project_root else None
-        )
-        self.regex_checker = RegexSafetyChecker()
-        
-        log_debug(f"SecurityValidator initialized with project_root: {project_root}")
-
-    def validate_file_path(
-        self, file_path: str, base_path: Optional[str] = None
-    ) -> Tuple[bool, str]:
-        """
-        Validate file path with comprehensive security checks.
-        
-        Implements multi-layer defense against path traversal attacks
-        and ensures file access stays within project boundaries.
-        
-        Args:
-            file_path: File path to validate
-            base_path: Optional base path for relative path validation
-            
-        Returns:
-            Tuple of (is_valid, error_message)
-            
-        Example:
-            >>> validator = SecurityValidator("/project/root")
-            >>> is_valid, error = validator.validate_file_path("src/main.py")
-            >>> assert is_valid
-        """
-        try:
-            # Layer 1: Basic input validation
-            if not file_path or not isinstance(file_path, str):
-                return False, "File path must be a non-empty string"
-            
-            # Layer 2: Null byte injection check
-            if "\x00" in file_path:
-                log_warning(f"Null byte detected in file path: {file_path}")
-                return False, "File path contains null bytes"
-            
-            # Layer 3: Windows drive letter check (only on non-Windows systems)
-            if len(file_path) > 1 and file_path[1] == ":" and os.name != 'nt':
-                return False, "Windows drive letters are not allowed on this system"
-
-            # Layer 4: Absolute path check (handle Windows leading slash/backslash explicitly)
-            is_abs = os.path.isabs(file_path) or (
-                os.name == 'nt' and (file_path.startswith('/') or file_path.startswith('\\'))
-            )
-            if is_abs:
-                # If we have a project root, check if the absolute path is within it
-                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"
-                else:
-                    # In test environments (temp directories), allow absolute paths
-                    import tempfile
-                    temp_dir = tempfile.gettempdir()
-                    if file_path.startswith(temp_dir):
-                        return True, ""
-                    # No project root defined, reject all other absolute paths
-                    return False, "Absolute file paths are not allowed"
-            
-            # Layer 5: Path normalization and traversal check
-            norm_path = os.path.normpath(file_path)
-            if "..\\" in norm_path or "../" in norm_path or norm_path.startswith(".."):
-                log_warning(f"Path traversal attempt detected: {file_path}")
-                return False, "Directory traversal not allowed"
-            
-            # Layer 6: Project boundary validation
-            if self.boundary_manager and base_path:
-                if not self.boundary_manager.is_within_project(
-                    os.path.join(base_path, norm_path)
-                ):
-                    return False, "Access denied. File path must be within project directory"
-            
-            # Layer 7: Symbolic link check (if file exists)
-            if base_path:
-                full_path = os.path.join(base_path, norm_path)
-                if os.path.exists(full_path) and os.path.islink(full_path):
-                    log_warning(f"Symbolic link detected: {full_path}")
-                    return False, "Symbolic links are not allowed"
-            
-            log_debug(f"File path validation passed: {file_path}")
-            return True, ""
-            
-        except Exception as e:
-            log_warning(f"File path validation error: {e}")
-            return False, f"Validation error: {str(e)}"
-
-    def validate_directory_path(
-        self, dir_path: str, must_exist: bool = True
-    ) -> Tuple[bool, str]:
-        """
-        Validate directory path for security and existence.
-        
-        Args:
-            dir_path: Directory path to validate
-            must_exist: Whether directory must exist
-            
-        Returns:
-            Tuple of (is_valid, error_message)
-        """
-        try:
-            # Basic validation using file path validator
-            is_valid, error = self.validate_file_path(dir_path)
-            if not is_valid:
-                return False, error
-            
-            # Check if path exists and is directory
-            if must_exist:
-                if not os.path.exists(dir_path):
-                    return False, f"Directory does not exist: {dir_path}"
-                
-                if not os.path.isdir(dir_path):
-                    return False, f"Path is not a directory: {dir_path}"
-            
-            log_debug(f"Directory path validation passed: {dir_path}")
-            return True, ""
-            
-        except Exception as e:
-            log_warning(f"Directory path validation error: {e}")
-            return False, f"Validation error: {str(e)}"
-
-    def validate_regex_pattern(self, pattern: str) -> Tuple[bool, str]:
-        """
-        Validate regex pattern for ReDoS attack prevention.
-        
-        Args:
-            pattern: Regex pattern to validate
-            
-        Returns:
-            Tuple of (is_valid, error_message)
-        """
-        return self.regex_checker.validate_pattern(pattern)
-
-    def sanitize_input(self, user_input: str, max_length: int = 1000) -> str:
-        """
-        Sanitize user input by removing dangerous characters.
-        
-        Args:
-            user_input: Input string to sanitize
-            max_length: Maximum allowed length
-            
-        Returns:
-            Sanitized input string
-            
-        Raises:
-            SecurityError: If input is too long or contains dangerous content
-        """
-        if not isinstance(user_input, str):
-            raise SecurityError("Input must be a string")
-        
-        if len(user_input) > max_length:
-            raise SecurityError(f"Input too long: {len(user_input)} > {max_length}")
-        
-        # Remove null bytes and control characters
-        sanitized = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]', '', user_input)
-
-        # Remove HTML/XML tags for XSS prevention
-        sanitized = re.sub(r'<[^>]*>', '', sanitized)
-
-        # Remove potentially dangerous characters
-        sanitized = re.sub(r'[<>"\']', '', sanitized)
-
-        # Log if sanitization occurred
-        if sanitized != user_input:
-            log_warning("Input sanitization performed")
-
-        return sanitized
-
-    def validate_glob_pattern(self, pattern: str) -> Tuple[bool, str]:
-        """
-        Validate glob pattern for safe file matching.
-        
-        Args:
-            pattern: Glob pattern to validate
-            
-        Returns:
-            Tuple of (is_valid, error_message)
-        """
-        try:
-            # Basic input validation
-            if not pattern or not isinstance(pattern, str):
-                return False, "Pattern must be a non-empty string"
-            
-            # Check for dangerous patterns
-            dangerous_patterns = [
-                "..",  # Path traversal
-                "//",  # Double slashes
-                "\\\\",  # Double backslashes
-            ]
-            
-            for dangerous in dangerous_patterns:
-                if dangerous in pattern:
-                    return False, f"Dangerous pattern detected: {dangerous}"
-            
-            # Validate length
-            if len(pattern) > 500:
-                return False, "Pattern too long"
-            
-            log_debug(f"Glob pattern validation passed: {pattern}")
-            return True, ""
-            
-        except Exception as e:
-            log_warning(f"Glob pattern validation error: {e}")
-            return False, f"Validation error: {str(e)}"
+#!/usr/bin/env python3
+"""
+Security Validator for Tree-sitter Analyzer
+
+Provides unified security validation framework inspired by code-index-mcp's
+ValidationHelper but enhanced for tree-sitter analyzer's requirements.
+"""
+
+import os
+import re
+from pathlib import Path
+from typing import Optional, Tuple
+
+from ..exceptions import SecurityError
+from ..utils import log_debug, log_warning
+from .boundary_manager import ProjectBoundaryManager
+from .regex_checker import RegexSafetyChecker
+
+
+class SecurityValidator:
+    """
+    Unified security validation framework.
+    
+    This class provides comprehensive security validation for file paths,
+    regex patterns, and other user inputs to prevent security vulnerabilities.
+    
+    Features:
+    - Multi-layer path traversal protection
+    - Project boundary enforcement
+    - ReDoS attack prevention
+    - Input sanitization
+    """
+
+    def __init__(self, project_root: Optional[str] = None) -> None:
+        """
+        Initialize security validator.
+        
+        Args:
+            project_root: Optional project root directory for boundary checks
+        """
+        self.boundary_manager = (
+            ProjectBoundaryManager(project_root) if project_root else None
+        )
+        self.regex_checker = RegexSafetyChecker()
+        
+        log_debug(f"SecurityValidator initialized with project_root: {project_root}")
+
+    def validate_file_path(
+        self, file_path: str, base_path: Optional[str] = None
+    ) -> Tuple[bool, str]:
+        """
+        Validate file path with comprehensive security checks.
+        
+        Implements multi-layer defense against path traversal attacks
+        and ensures file access stays within project boundaries.
+        
+        Args:
+            file_path: File path to validate
+            base_path: Optional base path for relative path validation
+            
+        Returns:
+            Tuple of (is_valid, error_message)
+            
+        Example:
+            >>> validator = SecurityValidator("/project/root")
+            >>> is_valid, error = validator.validate_file_path("src/main.py")
+            >>> assert is_valid
+        """
+        try:
+            # Layer 1: Basic input validation
+            if not file_path or not isinstance(file_path, str):
+                return False, "File path must be a non-empty string"
+            
+            # Layer 2: Null byte injection check
+            if "\x00" in file_path:
+                log_warning(f"Null byte detected in file path: {file_path}")
+                return False, "File path contains null bytes"
+            
+            # Layer 3: Windows drive letter check (only on non-Windows systems)
+            if len(file_path) > 1 and file_path[1] == ":" and os.name != 'nt':
+                return False, "Windows drive letters are not allowed on this system"
+
+            # Layer 4: Absolute path check
+            if os.path.isabs(file_path):
+                # If we have a project root, check if the absolute path is within it
+                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"
+                else:
+                    # In test environments (temp directories), allow absolute paths
+                    import tempfile
+                    temp_dir = tempfile.gettempdir()
+                    if file_path.startswith(temp_dir):
+                        return True, ""
+                    # No project root defined, reject all other absolute paths
+                    return False, "Absolute file paths are not allowed"
+            
+            # Layer 5: Path normalization and traversal check
+            norm_path = os.path.normpath(file_path)
+            if "..\\" in norm_path or "../" in norm_path or norm_path.startswith(".."):
+                log_warning(f"Path traversal attempt detected: {file_path}")
+                return False, "Directory traversal not allowed"
+            
+            # Layer 6: Project boundary validation
+            if self.boundary_manager and base_path:
+                if not self.boundary_manager.is_within_project(
+                    os.path.join(base_path, norm_path)
+                ):
+                    return False, "Access denied. File path must be within project directory"
+            
+            # Layer 7: Symbolic link check (if file exists)
+            if base_path:
+                full_path = os.path.join(base_path, norm_path)
+                if os.path.exists(full_path) and os.path.islink(full_path):
+                    log_warning(f"Symbolic link detected: {full_path}")
+                    return False, "Symbolic links are not allowed"
+            
+            log_debug(f"File path validation passed: {file_path}")
+            return True, ""
+            
+        except Exception as e:
+            log_warning(f"File path validation error: {e}")
+            return False, f"Validation error: {str(e)}"
+
+    def validate_directory_path(
+        self, dir_path: str, must_exist: bool = True
+    ) -> Tuple[bool, str]:
+        """
+        Validate directory path for security and existence.
+        
+        Args:
+            dir_path: Directory path to validate
+            must_exist: Whether directory must exist
+            
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        try:
+            # Basic validation using file path validator
+            is_valid, error = self.validate_file_path(dir_path)
+            if not is_valid:
+                return False, error
+            
+            # Check if path exists and is directory
+            if must_exist:
+                if not os.path.exists(dir_path):
+                    return False, f"Directory does not exist: {dir_path}"
+                
+                if not os.path.isdir(dir_path):
+                    return False, f"Path is not a directory: {dir_path}"
+            
+            log_debug(f"Directory path validation passed: {dir_path}")
+            return True, ""
+            
+        except Exception as e:
+            log_warning(f"Directory path validation error: {e}")
+            return False, f"Validation error: {str(e)}"
+
+    def validate_regex_pattern(self, pattern: str) -> Tuple[bool, str]:
+        """
+        Validate regex pattern for ReDoS attack prevention.
+        
+        Args:
+            pattern: Regex pattern to validate
+            
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        return self.regex_checker.validate_pattern(pattern)
+
+    def sanitize_input(self, user_input: str, max_length: int = 1000) -> str:
+        """
+        Sanitize user input by removing dangerous characters.
+        
+        Args:
+            user_input: Input string to sanitize
+            max_length: Maximum allowed length
+            
+        Returns:
+            Sanitized input string
+            
+        Raises:
+            SecurityError: If input is too long or contains dangerous content
+        """
+        if not isinstance(user_input, str):
+            raise SecurityError("Input must be a string")
+        
+        if len(user_input) > max_length:
+            raise SecurityError(f"Input too long: {len(user_input)} > {max_length}")
+        
+        # Remove null bytes and control characters
+        sanitized = re.sub(r'[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]', '', user_input)
+
+        # Remove HTML/XML tags for XSS prevention
+        sanitized = re.sub(r'<[^>]*>', '', sanitized)
+
+        # Remove potentially dangerous characters
+        sanitized = re.sub(r'[<>"\']', '', sanitized)
+
+        # Log if sanitization occurred
+        if sanitized != user_input:
+            log_warning("Input sanitization performed")
+
+        return sanitized
+
+    def validate_glob_pattern(self, pattern: str) -> Tuple[bool, str]:
+        """
+        Validate glob pattern for safe file matching.
+        
+        Args:
+            pattern: Glob pattern to validate
+            
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        try:
+            # Basic input validation
+            if not pattern or not isinstance(pattern, str):
+                return False, "Pattern must be a non-empty string"
+            
+            # Check for dangerous patterns
+            dangerous_patterns = [
+                "..",  # Path traversal
+                "//",  # Double slashes
+                "\\\\",  # Double backslashes
+            ]
+            
+            for dangerous in dangerous_patterns:
+                if dangerous in pattern:
+                    return False, f"Dangerous pattern detected: {dangerous}"
+            
+            # Validate length
+            if len(pattern) > 500:
+                return False, "Pattern too long"
+            
+            log_debug(f"Glob pattern validation passed: {pattern}")
+            return True, ""
+            
+        except Exception as e:
+            log_warning(f"Glob pattern validation error: {e}")
+            return False, f"Validation error: {str(e)}"

{tree_sitter_analyzer-0.8.3.dist-info → tree_sitter_analyzer-0.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tree-sitter-analyzer
-Version: 0.8.3
+Version: 0.9.1
 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,7 +137,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-1358%20passed-brightgreen.svg)](#testing)
+[![Tests](https://img.shields.io/badge/tests-306%20passed-brightgreen.svg)](#testing)
 [![Coverage](https://img.shields.io/badge/coverage-74.82%25-green.svg)](#testing)
 [![Quality](https://img.shields.io/badge/quality-enterprise%20grade-blue.svg)](#quality)
 
@@ -228,11 +228,10 @@ Extract specific code sections efficiently:
 - Content length information
 
 ### 3. AI Assistant Integration
-Four powerful MCP tools for AI assistants:
-- `analyze_code_scale` - Get code metrics and complexity
-- `analyze_code_structure` - Generate detailed structure tables
-- `read_code_partial` - Extract specific line ranges
-- `analyze_code_universal` - Universal analysis with auto-detection
+Three-step workflow MCP tools for AI assistants:
+- `check_code_scale` - **Step 1:** Get code metrics and complexity
+- `analyze_code_structure` - **Step 2:** Generate detailed structure tables with line positions
+- `extract_code_section` - **Step 3:** Extract specific code sections by line range
 
 ### 4. Multi-Language Support
 - **Java** - Full support with advanced analysis
@@ -244,14 +243,25 @@ Four powerful MCP tools for AI assistants:
 
 ### AI Assistant Usage (via Claude Desktop)
 
-**Step 1: Get code overview:**
-> "What's the overall complexity and size of this Java file examples/Sample.java?"
+**Step 1: Check code scale**
+```
+Use tool: check_code_scale
+Parameters: {"file_path": "examples/Sample.java"}
+```
 
-**Step 2: Analyze code structure (for large files):**
-> "Please analyze the structure of examples/Sample.java and show me a detailed table"
+**Step 2: Analyze structure (for large files >100 lines)**
+```
+Use tool: analyze_code_structure
+Parameters: {"file_path": "examples/Sample.java", "format_type": "full"}
+```
+
+**Step 3: Extract specific code (using line positions from step 2)**
+```
+Use tool: extract_code_section
+Parameters: {"file_path": "examples/Sample.java", "start_line": 84, "end_line": 86}
+```
 
-**Step 3: Extract specific code:**
-> "Show me lines 84-86 from examples/Sample.java"
+> **Note:** Always use snake_case parameter names: `file_path`, `start_line`, `end_line`, `format_type`
 
 ### CLI Usage
 
@@ -344,12 +354,11 @@ This project maintains **enterprise-grade quality** with comprehensive testing:
 - **Zero test failures** - Complete CI/CD readiness
 - **Cross-platform compatibility** - Windows, macOS, Linux
 
-### 🏆 Recent Quality Achievements (v0.8.2+)
-- ✅ **Complete test suite stabilization** - All 1358 tests passing
-- ✅ **Windows compatibility improvements** - Fixed path handling and security validation
-- ✅ **Enhanced error messaging** - Consistent CLI and MCP error reporting
-- ✅ **Performance optimizations** - Improved timing accuracy in analysis tools
-- ✅ **Security framework enhancements** - Better project boundary management
+### 🏆 Recent Quality Achievements (v0.8.2)
+- ✅ **Complete test suite stabilization** - Fixed all 31 failing tests
+- ✅ **Formatters module breakthrough** - 0% → 42.30% coverage
+- ✅ **Error handling improvements** - 61.64% → 82.76% coverage
+- ✅ **104 new comprehensive tests** across critical modules
 
 ### 🔧 Running Tests
 ```bash

{tree_sitter_analyzer-0.8.3.dist-info → tree_sitter_analyzer-0.9.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-tree_sitter_analyzer/__init__.py,sha256=_3nXMz3u_gwDfCxRMCiy5AzN7_CA7lp9Jpe4ovI19EE,3199
+tree_sitter_analyzer/__init__.py,sha256=ToixgdoKI2Cp-Uj4bCiJIrMRcMptWOv6olr1C6iNKnE,3199
 tree_sitter_analyzer/__main__.py,sha256=ilhMPpn_ar28oelzxLfQcX6WH_UbQ2euxiSoV3z_yCg,239
 tree_sitter_analyzer/api.py,sha256=_94HoE1LKGELSE6FpZ6pEqm2R7qfoPokyfpGSjawliQ,17487
 tree_sitter_analyzer/cli_main.py,sha256=ses68m5tLoYMP6Co3Fk2vqBACuFd38MqF85uEoa0mbw,9714
@@ -18,7 +18,7 @@ tree_sitter_analyzer/cli/__main__.py,sha256=xgCuvLv5NNeEsxKM40pF_7b1apgj3DZ4ECa-
 tree_sitter_analyzer/cli/info_commands.py,sha256=0x_6mfMq7jpKBLT9jzhTikXcs0n4TzNEV2Te9dyKNd4,4405
 tree_sitter_analyzer/cli/commands/__init__.py,sha256=qLtJ7rRge-Reu4aZbczn_jmUHQNQ4lEAsve9BZYHYd0,697
 tree_sitter_analyzer/cli/commands/advanced_command.py,sha256=YJGrFBEqFPpS0VB-o28Un89Cjwr-eTirNdcFLP4rlN8,3512
-tree_sitter_analyzer/cli/commands/base_command.py,sha256=m-qt6BK8zmK0lLuN__lqZhwI6Vyr_P1yntQ71UvyBNY,6823
+tree_sitter_analyzer/cli/commands/base_command.py,sha256=0CyODjCOWahH2x-PdeirxrKJMBNzTeRkfPvPuimhIXA,6770
 tree_sitter_analyzer/cli/commands/default_command.py,sha256=R9_GuI5KVYPK2DfXRuG8L89vwxv0QVW8sur_sigjZKo,542
 tree_sitter_analyzer/cli/commands/partial_read_command.py,sha256=kD3E2f1zCseSKpGQ3bgHnEuCq-DCPRQrT91JJJh8B4Q,4776
 tree_sitter_analyzer/cli/commands/query_command.py,sha256=TNkmuUKaTmTYD80jc8eesYLpw59YVk-6nw478SsYWH8,3640
@@ -45,16 +45,16 @@ tree_sitter_analyzer/languages/__init__.py,sha256=D-b1wReVcu3XRBvbeWgO80i29naGJ6
 tree_sitter_analyzer/languages/java_plugin.py,sha256=o_9F_anKCemnUDV6hq28RatRmBm3e0nchcQZ-v0nDv4,48454
 tree_sitter_analyzer/languages/javascript_plugin.py,sha256=9al0ScXmM5Y8Xl82oNp7cUaU9P59eNCJCPXSlfea4u8,16290
 tree_sitter_analyzer/languages/python_plugin.py,sha256=nlVxDx6thOB5o6QfQzGbD7gph3_YuM32YYzqYZoHlMw,29899
-tree_sitter_analyzer/mcp/__init__.py,sha256=mL_XjEks3tJOGAl9ULs_09KQOH1BWi92yvXpBidwmlI,752
-tree_sitter_analyzer/mcp/server.py,sha256=guh8Z4JPw3S_-qpQwAIY8V3KxZCskHXokB-EQhI6mqo,17015
+tree_sitter_analyzer/mcp/__init__.py,sha256=udPIWx_nP4UoCjX0xVybElPQgWycAFYd3x7TrQS18Bs,1475
+tree_sitter_analyzer/mcp/server.py,sha256=6WoRAV4ro_2OdwpT9Yj3D_GiUMhnvH8CmQ6D2AvmUzo,23688
 tree_sitter_analyzer/mcp/resources/__init__.py,sha256=PHDvZyHZawoToDQVqrepsmcTk00ZlaTsu6uxwVjoa4A,1433
 tree_sitter_analyzer/mcp/resources/code_file_resource.py,sha256=MDHvJl6akElHtcxlN6eCcY5WYSjQEQFCyhAVGiPGk9s,6462
 tree_sitter_analyzer/mcp/resources/project_stats_resource.py,sha256=lZF9TGxjKvTwPyuWE_o3I3V4LK0zEj3lab4L0Iq-hho,19758
 tree_sitter_analyzer/mcp/tools/__init__.py,sha256=RMvJOzfZMVe24WUNWJJ-pdygc1RbEVrhW5NZwpykDoQ,792
-tree_sitter_analyzer/mcp/tools/analyze_scale_tool.py,sha256=-xVdDuo45X1O-IYKzJvJRM4LlISKWMJmEKCC7sJp3v0,27388
-tree_sitter_analyzer/mcp/tools/analyze_scale_tool_cli_compatible.py,sha256=1RjsEMS8n9hBmipbgIjw-sAykFRmMZzW53w5be1Ps24,9040
+tree_sitter_analyzer/mcp/tools/analyze_scale_tool.py,sha256=yI33yev1W-MztyjiPlSX4uwCcFigRpzdHloXNCXAQz8,27938
+tree_sitter_analyzer/mcp/tools/analyze_scale_tool_cli_compatible.py,sha256=Ie1yeGTFNxuEeTLgXVnKEdKktoMEV27ychIMVkStRY8,9244
 tree_sitter_analyzer/mcp/tools/base_tool.py,sha256=szW84sSYejzRyBlFbskOARQbsfc2JLwHmjZ6rJZ8SQA,1264
-tree_sitter_analyzer/mcp/tools/read_partial_tool.py,sha256=Hjfl1-b0BVsT-g6zr0-pxXA0T1tKaE0iLJZFMm-fxRI,11505
+tree_sitter_analyzer/mcp/tools/read_partial_tool.py,sha256=O8zfxZ6FGKfVXeuQfjoCNul02-2Jn7mOg_Hoxy8cxxM,11457
 tree_sitter_analyzer/mcp/tools/table_format_tool.py,sha256=JUfkB32ZXf-RQ5O2nKC2jFTVR1AxD8lks5vjjDFEoNw,15502
 tree_sitter_analyzer/mcp/tools/universal_analyze_tool.py,sha256=MbJEzWa0b2KtHLIgmy5WVcCN89YL4tB1drujoHt9axs,22173
 tree_sitter_analyzer/mcp/utils/__init__.py,sha256=F_qFFC2gvGNdgRWGLxIh4Amd0dPhZv0Ni1ZbCbaYLlI,3063
@@ -68,10 +68,10 @@ tree_sitter_analyzer/queries/javascript.py,sha256=wIv5k-l48e1_sW_vqNUBkdNKO97CBs
 tree_sitter_analyzer/queries/python.py,sha256=tl72D3JTOSNIG-1lXww0YKQ41AgMKB5iBUkNBaqfkiI,7855
 tree_sitter_analyzer/queries/typescript.py,sha256=I1ndwPjAMGOIa1frSK3ewLqEkeDAJuAE9qzD9seEGf4,6937
 tree_sitter_analyzer/security/__init__.py,sha256=AlBGtSpDqVxlfM4K7JD-dJsDE8cPcuzJvN7OOsNOhm8,646
-tree_sitter_analyzer/security/boundary_manager.py,sha256=g1xPsBIx2w0hbqor7f2T2cSJ0_4ztSL_v-l076U-G54,9439
+tree_sitter_analyzer/security/boundary_manager.py,sha256=jj7iHiZiMxC590aiw7oUlTjztGxY8WqauG8Rwu8n6Ig,8288
 tree_sitter_analyzer/security/regex_checker.py,sha256=glKsja9zbrP_kOkaXxPkzkkUjLZpO1EBCi3LS3fobmQ,10317
-tree_sitter_analyzer/security/validator.py,sha256=CbEQsKjw3F3MyU8WSOhFYy0SeAYdxORhLWI3ymxDBvo,9311
-tree_sitter_analyzer-0.8.3.dist-info/METADATA,sha256=0wTQ2VYQgpwasWzdiMUtQkPkzpkC_m9_5NztpT83kz8,15767
-tree_sitter_analyzer-0.8.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-tree_sitter_analyzer-0.8.3.dist-info/entry_points.txt,sha256=EA0Ow27x2SqNt2300sv70RTWxKRIxJzOhNPIVlez4NM,417
-tree_sitter_analyzer-0.8.3.dist-info/RECORD,,
+tree_sitter_analyzer/security/validator.py,sha256=6rbf2fWOxwgMqFqrRqhblcPUsXDOiaij9gd6l1owhXw,9359
+tree_sitter_analyzer-0.9.1.dist-info/METADATA,sha256=xGxnZmp2tpuCVELZpkChnwH6TRTvjRqXvj6pbyj_5m4,15893
+tree_sitter_analyzer-0.9.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+tree_sitter_analyzer-0.9.1.dist-info/entry_points.txt,sha256=EA0Ow27x2SqNt2300sv70RTWxKRIxJzOhNPIVlez4NM,417
+tree_sitter_analyzer-0.9.1.dist-info/RECORD,,