tree-sitter-analyzer 0.8.0__py3-none-any.whl → 0.8.1__py3-none-any.whl

tree_sitter_analyzer/cli/commands/base_command.py

@@ -15,6 +15,8 @@ from ...file_handler import read_file_partial
 from ...language_detector import detect_language_from_file, is_language_supported
 from ...models import AnalysisResult
 from ...output_manager import output_error, output_info
+from ...project_detector import detect_project_root
+from ...security import SecurityValidator
 
 
 class BaseCommand(ABC):
@@ -28,18 +30,32 @@ class BaseCommand(ABC):
     def __init__(self, args: Namespace):
         """Initialize command with parsed arguments."""
         self.args = args
-        self.analysis_engine = get_analysis_engine()
+
+        # Detect project root with priority handling
+        file_path = getattr(args, 'file_path', None)
+        explicit_root = getattr(args, 'project_root', None)
+        self.project_root = detect_project_root(file_path, explicit_root)
+
+        # Initialize components with project root
+        self.analysis_engine = get_analysis_engine(self.project_root)
+        self.security_validator = SecurityValidator(self.project_root)
 
     def validate_file(self) -> bool:
         """Validate input file exists and is accessible."""
         if not hasattr(self.args, "file_path") or not self.args.file_path:
-            output_error("ERROR: File path not specified.")
+            output_error("File path not specified.")
+            return False
+
+        # Security validation
+        is_valid, error_msg = self.security_validator.validate_file_path(self.args.file_path)
+        if not is_valid:
+            output_error(f"Invalid file path: {error_msg}")
             return False
 
         import os
 
         if not os.path.exists(self.args.file_path):
-            output_error(f"ERROR: File not found: {self.args.file_path}")
+            output_error(f"File not found: {self.args.file_path}")
             return False
 
         return True
@@ -47,7 +63,9 @@ class BaseCommand(ABC):
     def detect_language(self) -> str | None:
         """Detect or validate the target language."""
         if hasattr(self.args, "language") and self.args.language:
-            target_language = self.args.language.lower()
+            # Sanitize language input
+            sanitized_language = self.security_validator.sanitize_input(self.args.language, max_length=50)
+            target_language = sanitized_language.lower()
             if (not hasattr(self.args, "table") or not self.args.table) and (
                 not hasattr(self.args, "quiet") or not self.args.quiet
             ):
@@ -94,10 +112,10 @@ class BaseCommand(ABC):
                         end_column=getattr(self.args, "end_column", None),
                     )
                     if partial_content is None:
-                        output_error("ERROR: Failed to read file partially")
+                        output_error("Failed to read file partially")
                         return None
                 except Exception as e:
-                    output_error(f"ERROR: Failed to read file partially: {e}")
+                    output_error(f"Failed to read file partially: {e}")
                     return None
 
             request = AnalysisRequest(
@@ -114,13 +132,13 @@ class BaseCommand(ABC):
                     if analysis_result
                     else "Unknown error"
                 )
-                output_error(f"ERROR: Analysis failed: {error_msg}")
+                output_error(f"Analysis failed: {error_msg}")
                 return None
 
             return analysis_result
 
         except Exception as e:
-            output_error(f"ERROR: An error occurred during analysis: {e}")
+            output_error(f"An error occurred during analysis: {e}")
             return None
 
     def execute(self) -> int:
@@ -143,7 +161,7 @@ class BaseCommand(ABC):
         try:
             return asyncio.run(self.execute_async(language))
         except Exception as e:
-            output_error(f"ERROR: An error occurred during command execution: {e}")
+            output_error(f"An error occurred during command execution: {e}")
             return 1
 
     @abstractmethod

tree_sitter_analyzer/cli/commands/default_command.py

@@ -14,5 +14,5 @@ class DefaultCommand(BaseCommand):
 
     async def execute_async(self, language: str) -> int:
         """Execute default command - show error for missing options."""
-        output_error("ERROR: Please specify a query or --advanced option")
+        output_error("Please specify a query or --advanced option")
         return 1

tree_sitter_analyzer/cli/commands/partial_read_command.py

@@ -28,7 +28,7 @@ class PartialReadCommand(BaseCommand):
         if not hasattr(self.args, "file_path") or not self.args.file_path:
             from ...output_manager import output_error
 
-            output_error("ERROR: File path not specified.")
+            output_error("File path not specified.")
             return False
 
         import os
@@ -36,7 +36,7 @@ class PartialReadCommand(BaseCommand):
         if not os.path.exists(self.args.file_path):
             from ...output_manager import output_error
 
-            output_error(f"ERROR: File not found: {self.args.file_path}")
+            output_error(f"File not found: {self.args.file_path}")
             return False
 
         return True
@@ -56,20 +56,20 @@ class PartialReadCommand(BaseCommand):
         if not self.args.start_line:
             from ...output_manager import output_error
 
-            output_error("ERROR: --start-line is required")
+            output_error("--start-line is required")
             return 1
 
         if self.args.start_line < 1:
             from ...output_manager import output_error
 
-            output_error("ERROR: --start-line must be 1 or greater")
+            output_error("--start-line must be 1 or greater")
             return 1
 
         if self.args.end_line and self.args.end_line < self.args.start_line:
             from ...output_manager import output_error
 
             output_error(
-                "ERROR: --end-line must be greater than or equal to --start-line"
+                "--end-line must be greater than or equal to --start-line"
             )
             return 1
 
@@ -86,7 +86,7 @@ class PartialReadCommand(BaseCommand):
             if partial_content is None:
                 from ...output_manager import output_error
 
-                output_error("ERROR: Failed to read file partially")
+                output_error("Failed to read file partially")
                 return 1
 
             # Output the result
@@ -96,7 +96,7 @@ class PartialReadCommand(BaseCommand):
         except Exception as e:
             from ...output_manager import output_error
 
-            output_error(f"ERROR: Failed to read file partially: {e}")
+            output_error(f"Failed to read file partially: {e}")
             return 1
 
     def _output_partial_content(self, content: str) -> None:

tree_sitter_analyzer/cli/commands/query_command.py

@@ -18,21 +18,28 @@ class QueryCommand(BaseCommand):
         query_to_execute = None
 
         if hasattr(self.args, "query_key") and self.args.query_key:
+            # Sanitize query key input
+            sanitized_query_key = self.security_validator.sanitize_input(self.args.query_key, max_length=100)
             try:
-                query_to_execute = query_loader.get_query(language, self.args.query_key)
+                query_to_execute = query_loader.get_query(language, sanitized_query_key)
                 if query_to_execute is None:
                     output_error(
-                        f"ERROR: Query '{self.args.query_key}' not found for language '{language}'"
+                        f"ERROR: Query '{sanitized_query_key}' not found for language '{language}'"
                     )
                     return 1
             except ValueError as e:
-                output_error(f"ERROR: {e}")
+                output_error(f"{e}")
                 return 1
         elif hasattr(self.args, "query_string") and self.args.query_string:
+            # Security check for query string (potential regex patterns)
+            is_safe, error_msg = self.security_validator.regex_checker.validate_pattern(self.args.query_string)
+            if not is_safe:
+                output_error(f"Unsafe query pattern: {error_msg}")
+                return 1
             query_to_execute = self.args.query_string
 
         if not query_to_execute:
-            output_error("ERROR: No query specified.")
+            output_error("No query specified.")
             return 1
 
         # Perform analysis

tree_sitter_analyzer/cli/commands/table_command.py

@@ -42,7 +42,7 @@ class TableCommand(BaseCommand):
             return 0
 
         except Exception as e:
-            output_error(f"ERROR: An error occurred during table format analysis: {e}")
+            output_error(f"An error occurred during table format analysis: {e}")
             return 1
 
     def _convert_to_structure_format(

tree_sitter_analyzer/cli/info_commands.py

@@ -78,7 +78,7 @@ class DescribeQueryCommand(InfoCommand):
 
             if query_description is None or query_content is None:
                 output_error(
-                    f"ERROR: Query '{self.args.describe_query}' not found for language '{language}'"
+                    f"Query '{self.args.describe_query}' not found for language '{language}'"
                 )
                 return 1
 
@@ -87,7 +87,7 @@ class DescribeQueryCommand(InfoCommand):
             )
             output_data(f"Query content:\n{query_content}")
         except ValueError as e:
-            output_error(f"ERROR: {e}")
+            output_error(f"{e}")
             return 1
         return 0
 

tree_sitter_analyzer/cli_main.py

@@ -166,6 +166,12 @@ def create_argument_parser() -> argparse.ArgumentParser:
         help="Explicitly specify language (auto-detected from extension if omitted)",
     )
 
+    # Project options
+    parser.add_argument(
+        "--project-root",
+        help="Project root directory for security validation (auto-detected if not specified)",
+    )
+
     # Logging options
     parser.add_argument(
         "--quiet",
@@ -201,25 +207,25 @@ def handle_special_commands(args: argparse.Namespace) -> int | None:
     # Validate partial read options
     if hasattr(args, "partial_read") and args.partial_read:
         if args.start_line is None:
-            output_error("ERROR: --start-line is required")
+            output_error("--start-line is required")
             return 1
 
         if args.start_line < 1:
-            output_error("ERROR: --start-line must be 1 or greater")
+            output_error("--start-line must be 1 or greater")
             return 1
 
         if args.end_line and args.end_line < args.start_line:
             output_error(
-                "ERROR: --end-line must be greater than or equal to --start-line"
+                "--end-line must be greater than or equal to --start-line"
             )
             return 1
 
         if args.start_column is not None and args.start_column < 0:
-            output_error("ERROR: --start-column must be 0 or greater")
+            output_error("--start-column must be 0 or greater")
             return 1
 
         if args.end_column is not None and args.end_column < 0:
-            output_error("ERROR: --end-column must be 0 or greater")
+            output_error("--end-column must be 0 or greater")
             return 1
 
     # Query language commands
@@ -279,9 +285,9 @@ def main() -> None:
         sys.exit(exit_code)
     else:
         if not args.file_path:
-            output_error("ERROR: File path not specified.")
+            output_error("File path not specified.")
         else:
-            output_error("ERROR: No executable command specified.")
+            output_error("No executable command specified.")
         parser.print_help()
         sys.exit(1)
 

tree_sitter_analyzer/core/analysis_engine.py

@@ -15,11 +15,12 @@ Roo Code compliance:
 import hashlib
 import threading
 from dataclasses import dataclass
-from typing import Any, Optional, Protocol
+from typing import Any, Dict, Optional, Protocol
 
 from ..models import AnalysisResult
 from ..plugins.base import LanguagePlugin as BaseLanguagePlugin
 from ..plugins.manager import PluginManager
+from ..security import SecurityValidator
 from ..utils import log_debug, log_error, log_info, log_performance
 from .cache_service import CacheService
 
@@ -204,32 +205,41 @@ class UnifiedAnalysisEngine:
         _performance_monitor: パフォーマンス監視
     """
 
-    _instance: Optional["UnifiedAnalysisEngine"] = None
+    _instances: Dict[str, "UnifiedAnalysisEngine"] = {}
     _lock: threading.Lock = threading.Lock()
 
-    def __new__(cls) -> "UnifiedAnalysisEngine":
-        """シングルトンパターンでインスタンス共有"""
-        if cls._instance is None:
+    def __new__(cls, project_root: str = None) -> "UnifiedAnalysisEngine":
+        """シングルトンパターンでインスタンス共有 (project_root aware)"""
+        # Create a key based on project_root for different instances
+        instance_key = project_root or "default"
+
+        if instance_key not in cls._instances:
             with cls._lock:
-                if cls._instance is None:
-                    cls._instance = super().__new__(cls)
-        return cls._instance
+                if instance_key not in cls._instances:
+                    instance = super().__new__(cls)
+                    cls._instances[instance_key] = instance
+                    # Mark as not initialized for this instance
+                    instance._initialized = False
 
-    def __init__(self) -> None:
+        return cls._instances[instance_key]
+
+    def __init__(self, project_root: str = None) -> None:
         """初期化（一度のみ実行）"""
-        if hasattr(self, "_initialized"):
+        if hasattr(self, "_initialized") and self._initialized:
             return
 
         self._cache_service = CacheService()
         self._plugin_manager = PluginManager()
         self._performance_monitor = PerformanceMonitor()
+        self._security_validator = SecurityValidator(project_root)
+        self._project_root = project_root
 
         # プラグインを自動ロード
         self._load_plugins()
 
         self._initialized = True
 
-        log_info("UnifiedAnalysisEngine initialized")
+        log_info(f"UnifiedAnalysisEngine initialized with project root: {project_root}")
 
     def _load_plugins(self) -> None:
         """利用可能なプラグインを自動ロード"""
@@ -265,6 +275,12 @@ class UnifiedAnalysisEngine:
         """
         log_info(f"Starting analysis for {request.file_path}")
 
+        # Security validation
+        is_valid, error_msg = self._security_validator.validate_file_path(request.file_path)
+        if not is_valid:
+            log_error(f"Security validation failed for file path: {request.file_path} - {error_msg}")
+            raise ValueError(f"Invalid file path: {error_msg}")
+
         # キャッシュチェック（CLI・MCP間で共有）
         cache_key = self._generate_cache_key(request)
         cached_result = await self._cache_service.get(cache_key)
@@ -323,6 +339,12 @@ class UnifiedAnalysisEngine:
         Returns:
             Analysis result
         """
+        # Security validation
+        is_valid, error_msg = self._security_validator.validate_file_path(file_path)
+        if not is_valid:
+            log_error(f"Security validation failed for file path: {file_path} - {error_msg}")
+            raise ValueError(f"Invalid file path: {error_msg}")
+
         request = AnalysisRequest(
             file_path=file_path,
             language=None,  # Auto-detect
@@ -545,11 +567,14 @@ class MockLanguagePlugin:
         )
 
 
-def get_analysis_engine() -> UnifiedAnalysisEngine:
+def get_analysis_engine(project_root: str = None) -> UnifiedAnalysisEngine:
     """
     統一解析エンジンのインスタンスを取得
 
+    Args:
+        project_root: Project root directory for security validation
+
     Returns:
         統一解析エンジンのシングルトンインスタンス
     """
-    return UnifiedAnalysisEngine()
+    return UnifiedAnalysisEngine(project_root)

tree_sitter_analyzer/mcp/server.py

@@ -6,8 +6,10 @@ This module provides the main MCP server that exposes tree-sitter analyzer
 functionality through the Model Context Protocol.
 """
 
+import argparse
 import asyncio
 import json
+import os
 import sys
 from typing import Any
 
@@ -43,6 +45,8 @@ except ImportError:
 
 
 from ..core.analysis_engine import get_analysis_engine
+from ..project_detector import detect_project_root
+from ..security import SecurityValidator
 from ..utils import setup_logger
 from . import MCP_INFO
 from .resources import CodeFileResource, ProjectStatsResource
@@ -64,16 +68,17 @@ class TreeSitterAnalyzerMCPServer:
     integrating with existing analyzer components.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, project_root: str = None) -> None:
         """Initialize the MCP server with analyzer components."""
         self.server: Server | None = None
-        self.analysis_engine = get_analysis_engine()
+        self.analysis_engine = get_analysis_engine(project_root)
+        self.security_validator = SecurityValidator(project_root)
         # Use unified analysis engine instead of deprecated AdvancedAnalyzer
 
-        # Initialize MCP tools
-        self.read_partial_tool: MCPTool = ReadPartialTool()
-        self.universal_analyze_tool: MCPTool = UniversalAnalyzeTool()
-        self.table_format_tool: MCPTool = TableFormatTool()
+        # Initialize MCP tools with security validation
+        self.read_partial_tool: MCPTool = ReadPartialTool(project_root)
+        self.universal_analyze_tool: MCPTool = UniversalAnalyzeTool(project_root)
+        self.table_format_tool: MCPTool = TableFormatTool(project_root)
 
         # Initialize MCP resources
         self.code_file_resource = CodeFileResource()
@@ -161,9 +166,25 @@ class TreeSitterAnalyzerMCPServer:
         async def handle_call_tool(
             name: str, arguments: dict[str, Any]
         ) -> list[TextContent]:
-            """Handle tool calls."""
+            """Handle tool calls with security validation."""
             try:
-                if name == "analyze_code_scale":
+                # Security validation for tool name
+                sanitized_name = self.security_validator.sanitize_input(name, max_length=100)
+
+                # Log tool call for audit
+                logger.info(f"MCP tool call: {sanitized_name} with args: {list(arguments.keys())}")
+
+                # Validate arguments contain no malicious content
+                for key, value in arguments.items():
+                    if isinstance(value, str):
+                        # Check for potential injection attempts
+                        if len(value) > 10000:  # Prevent extremely large inputs
+                            raise ValueError(f"Input too large for parameter {key}")
+
+                        # Basic sanitization for string inputs
+                        sanitized_value = self.security_validator.sanitize_input(value, max_length=10000)
+                        arguments[key] = sanitized_value
+                if sanitized_name == "analyze_code_scale":
                     result = await self._analyze_code_scale(arguments)
                     return [
                         TextContent(
@@ -171,7 +192,7 @@ class TreeSitterAnalyzerMCPServer:
                             text=json.dumps(result, indent=2, ensure_ascii=False),
                         )
                     ]
-                elif name == "read_code_partial":
+                elif sanitized_name == "read_code_partial":
                     result = await self.read_partial_tool.execute(arguments)
                     return [
                         TextContent(
@@ -179,7 +200,7 @@ class TreeSitterAnalyzerMCPServer:
                             text=json.dumps(result, indent=2, ensure_ascii=False),
                         )
                     ]
-                elif name == "format_table":
+                elif sanitized_name == "format_table":
                     result = await self.table_format_tool.execute(arguments)
                     return [
                         TextContent(
@@ -187,7 +208,7 @@ class TreeSitterAnalyzerMCPServer:
                             text=json.dumps(result, indent=2, ensure_ascii=False),
                         )
                     ]
-                elif name == "analyze_code_universal":
+                elif sanitized_name == "analyze_code_universal":
                     result = await self.universal_analyze_tool.execute(arguments)
                     return [
                         TextContent(
@@ -318,10 +339,51 @@ class TreeSitterAnalyzerMCPServer:
                 pass  # Silently ignore logging errors during shutdown
 
 
+def parse_mcp_args(args=None) -> argparse.Namespace:
+    """Parse command line arguments for MCP server."""
+    parser = argparse.ArgumentParser(
+        description="Tree-sitter Analyzer MCP Server",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Environment Variables:
+  TREE_SITTER_PROJECT_ROOT    Project root directory (alternative to --project-root)
+
+Examples:
+  python -m tree_sitter_analyzer.mcp.server
+  python -m tree_sitter_analyzer.mcp.server --project-root /path/to/project
+        """
+    )
+
+    parser.add_argument(
+        "--project-root",
+        help="Project root directory for security validation (auto-detected if not specified)"
+    )
+
+    return parser.parse_args(args)
+
+
 async def main() -> None:
     """Main entry point for the MCP server."""
     try:
-        server = TreeSitterAnalyzerMCPServer()
+        # Parse command line arguments (empty list for testing)
+        args = parse_mcp_args([])
+
+        # Determine project root with priority handling
+        project_root = None
+
+        # Priority 1: Command line argument
+        if args.project_root:
+            project_root = args.project_root
+        # Priority 2: Environment variable
+        elif os.getenv('TREE_SITTER_PROJECT_ROOT'):
+            project_root = os.getenv('TREE_SITTER_PROJECT_ROOT')
+        # Priority 3: Auto-detection from current directory
+        else:
+            project_root = detect_project_root()
+
+        logger.info(f"MCP server starting with project root: {project_root}")
+
+        server = TreeSitterAnalyzerMCPServer(project_root)
         await server.run()
     except KeyboardInterrupt:
         try:

tree_sitter_analyzer/mcp/tools/analyze_scale_tool.py

@@ -13,6 +13,7 @@ from typing import Any
 
 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
 
 # Set up logging
@@ -28,11 +29,13 @@ class AnalyzeScaleTool:
     for LLM workflow efficiency.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, project_root: str = None) -> None:
         """Initialize the analyze scale tool."""
         # Use unified analysis engine instead of deprecated AdvancedAnalyzer
-        self.analysis_engine = get_analysis_engine()
-        logger.info("AnalyzeScaleTool initialized")
+        self.project_root = project_root
+        self.analysis_engine = get_analysis_engine(project_root)
+        self.security_validator = SecurityValidator(project_root)
+        logger.info("AnalyzeScaleTool initialized with security validation")
 
     def _calculate_file_metrics(self, file_path: str) -> dict[str, Any]:
         """
@@ -251,6 +254,12 @@ class AnalyzeScaleTool:
         if total_lines > 200:
             guidance["recommended_tools"].append("read_code_partial")
 
+        # Ensure all required fields exist
+        required_fields = ["complexity_hotspots", "classes", "methods", "fields", "imports"]
+        for field in required_fields:
+            if field not in structural_overview:
+                structural_overview[field] = []
+
         if len(structural_overview["complexity_hotspots"]) > 0:
             guidance["recommended_tools"].append("format_table")
             guidance["complexity_assessment"] = (
@@ -339,6 +348,16 @@ 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)
+        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}")
+
+        # Sanitize inputs
+        if language:
+            language = self.security_validator.sanitize_input(language, max_length=50)
+
         # Validate file exists
         if not Path(file_path).exists():
             raise FileNotFoundError(f"File not found: {file_path}")

tree_sitter_analyzer/mcp/tools/read_partial_tool.py

@@ -11,6 +11,7 @@ from pathlib import Path
 from typing import Any
 
 from ...file_handler import read_file_partial
+from ...security import SecurityValidator
 from ...utils import setup_logger
 
 # Set up logging
@@ -25,9 +26,10 @@ class ReadPartialTool:
     selective file content reading through the MCP protocol.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, project_root: str = None) -> None:
         """Initialize the read partial tool."""
-        logger.info("ReadPartialTool initialized")
+        self.security_validator = SecurityValidator(project_root)
+        logger.info("ReadPartialTool initialized with security validation")
 
     def get_tool_schema(self) -> dict[str, Any]:
         """
@@ -102,6 +104,12 @@ class ReadPartialTool:
         end_column = arguments.get("end_column")
         # output_format = arguments.get("format", "text")  # Not used currently
 
+        # Security validation
+        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}")
+
         # Validate file exists
         if not Path(file_path).exists():
             raise FileNotFoundError(f"File not found: {file_path}")

tree_sitter_analyzer/mcp/tools/table_format_tool.py

@@ -11,6 +11,7 @@ from typing import Any
 
 from ...core.analysis_engine import AnalysisRequest, get_analysis_engine
 from ...language_detector import detect_language_from_file
+from ...security import SecurityValidator
 from ...table_formatter import TableFormatter
 from ...utils import setup_logger
 from ..utils import get_performance_monitor
@@ -28,11 +29,13 @@ class TableFormatTool:
     the CLI --table=full option.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, project_root: str = None) -> None:
         """Initialize the table format tool."""
         self.logger = logger
-        self.analysis_engine = get_analysis_engine()
-        logger.info("TableFormatTool initialized")
+        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")
 
     def get_tool_schema(self) -> dict[str, Any]:
         """
@@ -268,6 +271,20 @@ class TableFormatTool:
             format_type = args.get("format_type", "full")
             language = args.get("language")
 
+            # Security validation
+            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}")
+
+            # Sanitize format_type input
+            if format_type:
+                format_type = self.security_validator.sanitize_input(format_type, max_length=50)
+
+            # Sanitize language input
+            if language:
+                language = self.security_validator.sanitize_input(language, max_length=50)
+
             # Validate file exists
             if not Path(file_path).exists():
                 raise FileNotFoundError(f"File not found: {file_path}")

tree_sitter_analyzer/mcp/tools/universal_analyze_tool.py

@@ -12,6 +12,7 @@ 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 get_performance_monitor
 from ..utils.error_handler import handle_mcp_errors
 
@@ -26,10 +27,13 @@ class UniversalAnalyzeTool:
     the appropriate analyzer to provide comprehensive code analysis.
     """
 
-    def __init__(self) -> None:
+    def __init__(self, project_root: str = None) -> None:
         """Initialize the universal analysis tool"""
         # Use unified analysis engine instead of deprecated AdvancedAnalyzer
-        self.analysis_engine = get_analysis_engine()
+        self.project_root = project_root
+        self.analysis_engine = get_analysis_engine(project_root)
+        self.security_validator = SecurityValidator(project_root)
+        logger.info("UniversalAnalyzeTool initialized with security validation")
 
     def get_tool_definition(self) -> dict[str, Any]:
         """
@@ -96,6 +100,18 @@ class UniversalAnalyzeTool:
         file_path = arguments["file_path"]
         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)
+        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}")
+
+        # Sanitize inputs
+        if language:
+            language = self.security_validator.sanitize_input(language, max_length=50)
+        if analysis_type:
+            analysis_type = self.security_validator.sanitize_input(analysis_type, max_length=50)
         include_ast = arguments.get("include_ast", False)
         include_queries = arguments.get("include_queries", False)
 

tree_sitter_analyzer/project_detector.py

@@ -0,0 +1,317 @@
+#!/usr/bin/env python3
+"""
+Project Root Detection
+
+Intelligent detection of project root directories based on common project markers.
+"""
+
+import os
+from pathlib import Path
+from typing import Optional, List, Tuple
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Common project root indicators (in priority order)
+PROJECT_MARKERS = [
+    # Version control
+    '.git',
+    '.hg',
+    '.svn',
+    
+    # Python projects
+    'pyproject.toml',
+    'setup.py',
+    'setup.cfg',
+    'requirements.txt',
+    'Pipfile',
+    'poetry.lock',
+    'conda.yaml',
+    'environment.yml',
+    
+    # JavaScript/Node.js projects
+    'package.json',
+    'package-lock.json',
+    'yarn.lock',
+    'node_modules',
+    
+    # Java projects
+    'pom.xml',
+    'build.gradle',
+    'build.gradle.kts',
+    'gradlew',
+    'mvnw',
+    
+    # C/C++ projects
+    'CMakeLists.txt',
+    'Makefile',
+    'configure.ac',
+    'configure.in',
+    
+    # Rust projects
+    'Cargo.toml',
+    'Cargo.lock',
+    
+    # Go projects
+    'go.mod',
+    'go.sum',
+    
+    # .NET projects
+    '*.sln',
+    '*.csproj',
+    '*.vbproj',
+    '*.fsproj',
+    
+    # Other common markers
+    'README.md',
+    'README.rst',
+    'README.txt',
+    'LICENSE',
+    'CHANGELOG.md',
+    '.gitignore',
+    '.dockerignore',
+    'Dockerfile',
+    'docker-compose.yml',
+    '.editorconfig',
+]
+
+
+class ProjectRootDetector:
+    """Intelligent project root directory detection."""
+    
+    def __init__(self, max_depth: int = 10):
+        """
+        Initialize project root detector.
+        
+        Args:
+            max_depth: Maximum directory levels to traverse upward
+        """
+        self.max_depth = max_depth
+    
+    def detect_from_file(self, file_path: str) -> Optional[str]:
+        """
+        Detect project root from a file path.
+        
+        Args:
+            file_path: Path to a file within the project
+            
+        Returns:
+            Project root directory path, or None if not detected
+        """
+        if not file_path:
+            return None
+            
+        try:
+            # Convert to absolute path and get directory
+            abs_path = os.path.abspath(file_path)
+            if os.path.isfile(abs_path):
+                start_dir = os.path.dirname(abs_path)
+            else:
+                start_dir = abs_path
+                
+            return self._traverse_upward(start_dir)
+            
+        except Exception as e:
+            logger.warning(f"Error detecting project root from {file_path}: {e}")
+            return None
+    
+    def detect_from_cwd(self) -> Optional[str]:
+        """
+        Detect project root from current working directory.
+        
+        Returns:
+            Project root directory path, or None if not detected
+        """
+        try:
+            return self._traverse_upward(os.getcwd())
+        except Exception as e:
+            logger.warning(f"Error detecting project root from cwd: {e}")
+            return None
+    
+    def _traverse_upward(self, start_dir: str) -> Optional[str]:
+        """
+        Traverse upward from start directory looking for project markers.
+        
+        Args:
+            start_dir: Directory to start traversal from
+            
+        Returns:
+            Project root directory path, or None if not found
+        """
+        current_dir = os.path.abspath(start_dir)
+        candidates = []
+        
+        for depth in range(self.max_depth):
+            # Check for project markers in current directory
+            markers_found = self._find_markers_in_dir(current_dir)
+            
+            if markers_found:
+                # Calculate score based on marker priority and count
+                score = self._calculate_score(markers_found)
+                candidates.append((current_dir, score, markers_found))
+                
+                # If we find high-priority markers, we can stop early
+                if any(marker in ['.git', 'pyproject.toml', 'package.json', 'pom.xml', 'Cargo.toml', 'go.mod'] 
+                       for marker in markers_found):
+                    logger.debug(f"Found high-priority project root: {current_dir} (markers: {markers_found})")
+                    return current_dir
+            
+            # Move up one directory
+            parent_dir = os.path.dirname(current_dir)
+            if parent_dir == current_dir:  # Reached filesystem root
+                break
+            current_dir = parent_dir
+        
+        # Return the best candidate if any found
+        if candidates:
+            # Sort by score (descending) and return the best
+            candidates.sort(key=lambda x: x[1], reverse=True)
+            best_candidate = candidates[0]
+            logger.debug(f"Selected project root: {best_candidate[0]} (score: {best_candidate[1]}, markers: {best_candidate[2]})")
+            return best_candidate[0]
+        
+        logger.debug(f"No project root detected from {start_dir}")
+        return None
+    
+    def _find_markers_in_dir(self, directory: str) -> List[str]:
+        """
+        Find project markers in a directory.
+        
+        Args:
+            directory: Directory to search in
+            
+        Returns:
+            List of found marker names
+        """
+        found_markers = []
+        
+        try:
+            dir_contents = os.listdir(directory)
+            
+            for marker in PROJECT_MARKERS:
+                if '*' in marker:
+                    # Handle glob patterns
+                    import glob
+                    pattern = os.path.join(directory, marker)
+                    if glob.glob(pattern):
+                        found_markers.append(marker)
+                else:
+                    # Handle exact matches
+                    if marker in dir_contents:
+                        found_markers.append(marker)
+                        
+        except (OSError, PermissionError) as e:
+            logger.debug(f"Cannot access directory {directory}: {e}")
+        
+        return found_markers
+    
+    def _calculate_score(self, markers: List[str]) -> int:
+        """
+        Calculate a score for project root candidates based on markers found.
+        
+        Args:
+            markers: List of found markers
+            
+        Returns:
+            Score (higher is better)
+        """
+        score = 0
+        
+        # High-priority markers
+        high_priority = ['.git', 'pyproject.toml', 'package.json', 'pom.xml', 'Cargo.toml', 'go.mod']
+        medium_priority = ['setup.py', 'requirements.txt', 'CMakeLists.txt', 'Makefile']
+        
+        for marker in markers:
+            if marker in high_priority:
+                score += 100
+            elif marker in medium_priority:
+                score += 50
+            else:
+                score += 10
+        
+        # Bonus for multiple markers
+        if len(markers) > 1:
+            score += len(markers) * 5
+        
+        return score
+    
+    def get_fallback_root(self, file_path: str) -> str:
+        """
+        Get fallback project root when detection fails.
+        
+        Args:
+            file_path: Original file path
+            
+        Returns:
+            Fallback directory (file's directory or cwd)
+        """
+        try:
+            if file_path and os.path.exists(file_path):
+                if os.path.isfile(file_path):
+                    return os.path.dirname(os.path.abspath(file_path))
+                else:
+                    return os.path.abspath(file_path)
+            else:
+                return os.getcwd()
+        except Exception:
+            return os.getcwd()
+
+
+def detect_project_root(file_path: Optional[str] = None, 
+                       explicit_root: Optional[str] = None) -> str:
+    """
+    Unified project root detection with priority handling.
+    
+    Priority order:
+    1. explicit_root parameter (highest priority)
+    2. Auto-detection from file_path
+    3. Auto-detection from current working directory
+    4. Fallback to file directory or cwd
+    
+    Args:
+        file_path: Path to a file within the project
+        explicit_root: Explicitly specified project root
+        
+    Returns:
+        Project root directory path
+    """
+    detector = ProjectRootDetector()
+    
+    # Priority 1: Explicit root
+    if explicit_root:
+        if os.path.exists(explicit_root) and os.path.isdir(explicit_root):
+            logger.info(f"Using explicit project root: {explicit_root}")
+            return os.path.abspath(explicit_root)
+        else:
+            logger.warning(f"Explicit project root does not exist: {explicit_root}")
+    
+    # Priority 2: Auto-detection from file path
+    if file_path:
+        detected_root = detector.detect_from_file(file_path)
+        if detected_root:
+            logger.info(f"Auto-detected project root from file: {detected_root}")
+            return detected_root
+    
+    # Priority 3: Auto-detection from cwd
+    detected_root = detector.detect_from_cwd()
+    if detected_root:
+        logger.info(f"Auto-detected project root from cwd: {detected_root}")
+        return detected_root
+    
+    # Priority 4: Fallback
+    fallback_root = detector.get_fallback_root(file_path)
+    logger.info(f"Using fallback project root: {fallback_root}")
+    return fallback_root
+
+
+if __name__ == "__main__":
+    # Test the detector
+    import sys
+    
+    if len(sys.argv) > 1:
+        test_path = sys.argv[1]
+        result = detect_project_root(test_path)
+        print(f"Project root for '{test_path}': {result}")
+    else:
+        result = detect_project_root()
+        print(f"Project root from cwd: {result}")

tree_sitter_analyzer/security/validator.py

@@ -76,13 +76,24 @@ class SecurityValidator:
                 log_warning(f"Null byte detected in file path: {file_path}")
                 return False, "File path contains null bytes"
             
-            # Layer 3: Windows drive letter check (before absolute path check)
-            if len(file_path) > 1 and file_path[1] == ":":
-                return False, "Windows drive letters are not allowed"
+            # 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 rejection
+            # Layer 4: Absolute path check
             if os.path.isabs(file_path):
-                return False, "Absolute file paths are not allowed"
+                # 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)
@@ -179,11 +190,17 @@ class SecurityValidator:
         
         # 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]:

{tree_sitter_analyzer-0.8.0.dist-info → tree_sitter_analyzer-0.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tree-sitter-analyzer
-Version: 0.8.0
+Version: 0.8.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
@@ -306,9 +306,32 @@ uv sync --extra all --extra mcp
 
 - **[MCP Setup Guide for Users](https://github.com/aimasteracc/tree-sitter-analyzer/blob/main/MCP_SETUP_USERS.md)** - Simple setup for AI assistant users
 - **[MCP Setup Guide for Developers](https://github.com/aimasteracc/tree-sitter-analyzer/blob/main/MCP_SETUP_DEVELOPERS.md)** - Local development configuration
+- **[Project Root Configuration](https://github.com/aimasteracc/tree-sitter-analyzer/blob/main/PROJECT_ROOT_CONFIG.md)** - Complete configuration reference
 - **[API Documentation](https://github.com/aimasteracc/tree-sitter-analyzer/blob/main/docs/api.md)** - Detailed API reference
 - **[Contributing Guide](https://github.com/aimasteracc/tree-sitter-analyzer/blob/main/CONTRIBUTING.md)** - How to contribute
 
+### 🔒 Project Root Configuration
+
+Tree-sitter-analyzer automatically detects and secures your project boundaries:
+
+- **Auto-detection**: Finds project root from `.git`, `pyproject.toml`, `package.json`, etc.
+- **CLI**: Use `--project-root /path/to/project` for explicit control
+- **MCP**: Set `TREE_SITTER_PROJECT_ROOT=${workspaceFolder}` for workspace integration
+- **Security**: Only analyzes files within project boundaries
+
+**Recommended MCP configuration:**
+```json
+{
+  "mcpServers": {
+    "tree-sitter-analyzer": {
+      "command": "uv",
+      "args": ["run", "--with", "tree-sitter-analyzer[mcp]", "python", "-m", "tree_sitter_analyzer.mcp.server"],
+      "env": {"TREE_SITTER_PROJECT_ROOT": "${workspaceFolder}"}
+    }
+  }
+}
+```
+
 ## 🧪 Testing
 
 This project maintains high code quality with **1126 passing tests**.

{tree_sitter_analyzer-0.8.0.dist-info → tree_sitter_analyzer-0.8.1.dist-info}/RECORD

@@ -1,7 +1,7 @@
 tree_sitter_analyzer/__init__.py,sha256=T8urKvmHQaqEoh_-jKgNJOb2Snz2ySjMqYWE53vLKKA,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=bJP7CUHMSSgbPrze7PmOYsVXJ1z1jfhaP0nIVkU7dRw,9581
+tree_sitter_analyzer/cli_main.py,sha256=ses68m5tLoYMP6Co3Fk2vqBACuFd38MqF85uEoa0mbw,9714
 tree_sitter_analyzer/encoding_utils.py,sha256=C5DpH2-qkAKfsJeSGNHbhOCy4bmn46X6rUw5xPpki34,14938
 tree_sitter_analyzer/exceptions.py,sha256=xO_U6JuJ4QPkmZoXL_3nmV9QUbTa7-hrI05VAuo5r-Y,12093
 tree_sitter_analyzer/file_handler.py,sha256=vl4bGx-OgC6Lq63FEZNu2XCXNM0iDTmpNCRTK2msP3U,7104
@@ -9,23 +9,24 @@ tree_sitter_analyzer/language_detector.py,sha256=IjkYF1E7_TtWlwYjz780ZUJAyPltL2a
 tree_sitter_analyzer/language_loader.py,sha256=gdLxkSoajm-q7c1vcvFONtBf5XJRgasUVI4L0wMzra0,8124
 tree_sitter_analyzer/models.py,sha256=z0aqdZOVA8rYWF0143TSAUoCvncVRLZ1O70eAjV87gU,16564
 tree_sitter_analyzer/output_manager.py,sha256=eiBOSL2vUUQi1ghYBr4gwT7aOYC2WTgIoISBZlXkzPo,8399
+tree_sitter_analyzer/project_detector.py,sha256=tB5giHVa_jvPv44l0gv7u265Ih28Fw2ADKUEkb1YFnk,9565
 tree_sitter_analyzer/query_loader.py,sha256=NilC2XmmhYrBL6ONlzRGlehGa23C_4V6nDVap6YG8v0,10120
 tree_sitter_analyzer/table_formatter.py,sha256=BfrAouAr3r6MD9xY9yhHw_PwD0aJ4BQo5p1UFhorT5k,27284
 tree_sitter_analyzer/utils.py,sha256=Pq_2vlDPul8jean0PwlQ_XC-RDjkuaUbwoXp2ls7dV8,8268
 tree_sitter_analyzer/cli/__init__.py,sha256=swCjWlrPEVIKGznqM_BPxbNvd_0Qz5r1_RmZ-j6EWIU,910
 tree_sitter_analyzer/cli/__main__.py,sha256=xgCuvLv5NNeEsxKM40pF_7b1apgj3DZ4ECa-xcbLKWc,230
-tree_sitter_analyzer/cli/info_commands.py,sha256=z6JhXO1Sm983dHj0uxNVzycWBYz1JIGVCOi0ukSAyTM,4419
+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=LNRTNYMpAuSAwyxM7rtA1oZcvWPMaAHXsBdv--FOGgw,5947
-tree_sitter_analyzer/cli/commands/default_command.py,sha256=-bJJC3Klie7EU3B3n_YXUYKAUSBzC2XUHP3XOnwENvQ,549
-tree_sitter_analyzer/cli/commands/partial_read_command.py,sha256=D8dY3CUaNn5EEPgrJNR4e7IClfJal7zenlbWxZcHwPQ,4825
-tree_sitter_analyzer/cli/commands/query_command.py,sha256=5SsxwJQInS0YQz9W6ZD_P88-wekfl7VKN_Utlm47YTk,3200
+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=5GlctGaJIc_3AGdISMNFJkbGB3hx6YixYBnKK8VmsF0,3647
 tree_sitter_analyzer/cli/commands/structure_command.py,sha256=u-NKm06CLgx4srdK5bVo7WtcV4dArA7WYWQWmeXcWMs,5358
 tree_sitter_analyzer/cli/commands/summary_command.py,sha256=X3pLK7t2ma4SDlG7yYsaFX6bQ4OVUrHv8OWDfgTMNMw,3703
-tree_sitter_analyzer/cli/commands/table_command.py,sha256=LuQWeWqCxOArrINcDY9fnXnFyWtESKpffwg_oMQByGw,9683
+tree_sitter_analyzer/cli/commands/table_command.py,sha256=BAIw26WRi_yXbKvkuV7tXFKzSiWvYKVzRUxAcgsJ7VQ,9676
 tree_sitter_analyzer/core/__init__.py,sha256=Um_BRFICWihZybxoAR6Ck32gJ42ZatkBoZR18XGl9FQ,455
-tree_sitter_analyzer/core/analysis_engine.py,sha256=pWyvdYOlTHyLTBcV90yg-yaWQRRi7MWbXTGhoylpzQ0,19122
+tree_sitter_analyzer/core/analysis_engine.py,sha256=Hp72NvmnWduDI1bn7ArKOT1ho9o2_0RZqj_lU_UMqjQ,20493
 tree_sitter_analyzer/core/cache_service.py,sha256=lTFhGsmuGWgEauxtk2pz_1h5Z945456CaQILfreS5Rw,9944
 tree_sitter_analyzer/core/engine.py,sha256=6NRPBlN1GvFDtSh8hDJ8udKLC7IOjvoCPetuM7MPrnw,19287
 tree_sitter_analyzer/core/parser.py,sha256=07vL-mESeMsaIrQqAg-3sr9MLWYVdzT5RyBDO1AkBh0,9586
@@ -45,17 +46,17 @@ tree_sitter_analyzer/languages/java_plugin.py,sha256=o_9F_anKCemnUDV6hq28RatRmBm
 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=uXV4hUroFRnHTP8_axkKWh2OkN3o6OwNxS-BjlrKMfA,12937
+tree_sitter_analyzer/mcp/server.py,sha256=7p5LdihdLMl0BH_u6vGk1VDLTiycLzAOeBsxaug4LrY,15669
 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=ZVNEghqKFOcLNZKsv9cJI19t8ZqcgcPp_bXiNkfoWps,26997
+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=aWBfJXDbjUpiu9xx_-89Js_GebB468mUyupAwT8oA5E,11035
-tree_sitter_analyzer/mcp/tools/table_format_tool.py,sha256=O9bxfwGNNjTNpBN5HJ5iTgKALoMTZ2HSYRryBZxaQu0,14623
-tree_sitter_analyzer/mcp/tools/universal_analyze_tool.py,sha256=1UslG_OpB9r1upX1xPYUSquRLYSVzglV8XgO3V2RJjs,21328
+tree_sitter_analyzer/mcp/tools/read_partial_tool.py,sha256=Hjfl1-b0BVsT-g6zr0-pxXA0T1tKaE0iLJZFMm-fxRI,11505
+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
 tree_sitter_analyzer/mcp/utils/error_handler.py,sha256=n9ME2U5L1o65Vewnv8kD2O8dVI1CiEGm1pLWdnpnyqM,17972
 tree_sitter_analyzer/plugins/__init__.py,sha256=MfSW8P9GLaL_9XgLISdlpIUY4quqapk0avPLIpBdMTg,10606
@@ -69,8 +70,8 @@ tree_sitter_analyzer/queries/typescript.py,sha256=I1ndwPjAMGOIa1frSK3ewLqEkeDAJu
 tree_sitter_analyzer/security/__init__.py,sha256=zVpzS5jtECwgYnhKL4YoMfnIdkJABnVeziTBB4IOTyU,624
 tree_sitter_analyzer/security/boundary_manager.py,sha256=e4iOJTygHLqlImkOntjLhfTpCvqCfb2LTpYwGpYmVQg,8051
 tree_sitter_analyzer/security/regex_checker.py,sha256=Qvldh-TiVYqtcYQbD80wk0eHUvhALYtWTWBy_bGmJUk,10025
-tree_sitter_analyzer/security/validator.py,sha256=RRGyacxCjJ2CbfvGzpZCvza8YxqSrOiO2JWY49oFMh8,8187
-tree_sitter_analyzer-0.8.0.dist-info/METADATA,sha256=JtFjrCj-g9vPbMvYKurXQXB8I8Ogxo_DGB_lATblvIk,13525
-tree_sitter_analyzer-0.8.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-tree_sitter_analyzer-0.8.0.dist-info/entry_points.txt,sha256=EA0Ow27x2SqNt2300sv70RTWxKRIxJzOhNPIVlez4NM,417
-tree_sitter_analyzer-0.8.0.dist-info/RECORD,,
+tree_sitter_analyzer/security/validator.py,sha256=yL72kKnMN2IeqJk3i9l9FpWP9_Mt4lPErpj8ys5J_WY,9118
+tree_sitter_analyzer-0.8.1.dist-info/METADATA,sha256=DGfahyUO9cgkNyyOUtwQrew4UtZbTSpanuhAivGRSN8,14422
+tree_sitter_analyzer-0.8.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+tree_sitter_analyzer-0.8.1.dist-info/entry_points.txt,sha256=EA0Ow27x2SqNt2300sv70RTWxKRIxJzOhNPIVlez4NM,417
+tree_sitter_analyzer-0.8.1.dist-info/RECORD,,