tree-sitter-analyzer 1.8.4__py3-none-any.whl → 1.9.1__py3-none-any.whl

tree_sitter_analyzer/security/validator.py

@@ -117,41 +117,49 @@ class SecurityValidator:
                 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}")
+                    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}")
+                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 + file_path) if base_path is provided
             if base_path:
                 norm_path = str(Path(file_path))
                 full_path = Path(base_path) / norm_path
-                
+
                 # 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):
+                    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):
@@ -163,7 +171,7 @@ class SecurityValidator:
             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):
@@ -299,14 +307,16 @@ class SecurityValidator:
             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]:
+    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)
         """
@@ -315,11 +325,11 @@ class SecurityValidator:
     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
         """
@@ -329,191 +339,208 @@ class SecurityValidator:
     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)
-                
+                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
 
     def _validate_windows_drive_letter(self, file_path: str) -> tuple[bool, str]:
         """
         Validate Windows drive letter on non-Windows systems.
-        
+
         Args:
             file_path: File path to validate
-            
+
         Returns:
             Tuple of (is_valid, error_message)
         """
         import platform
-        
+
         if (
             len(file_path) > 1
             and file_path[1] == ":"
             and platform.system() != "Windows"
         ):
-            return False, f"Windows drive letters are not allowed on {platform.system()} system"
-        
+            return (
+                False,
+                f"Windows drive letters are not allowed on {platform.system()} system",
+            )
+
         return True, ""
 
     def _validate_absolute_path(self, file_path: str) -> tuple[bool, str]:
         """
         Validate absolute path with project boundary and test environment checks.
-        
+
         Args:
             file_path: Absolute file path to validate
-            
+
         Returns:
             Tuple of (is_valid, error_message)
         """
         log_debug(f"Processing absolute path: {file_path}")
-        
+
         # Check project boundaries first (highest priority)
         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"
             log_debug("Absolute path is within project boundaries")
             return True, ""
-        
+
         # If no project boundaries, check test environment allowances
         is_test_allowed, error = self._check_test_environment_access(file_path)
         if not is_test_allowed:
             return False, error
-            
+
         log_debug("Absolute path allowed in test environment")
         return True, ""
 
     def _check_test_environment_access(self, file_path: str) -> tuple[bool, str]:
         """
         Check if absolute path access is allowed in test/development environment.
-        
+
         This method allows access to system temporary directories when no project
         boundaries are configured, which is common in test environments.
-        
+
         Args:
             file_path: File path to check
-            
+
         Returns:
             Tuple of (is_allowed, error_message)
         """
-        import tempfile
         import os
-        
+        import tempfile
+
         try:
             # Check if we're in a test environment
             is_test_env = (
-                "pytest" in os.environ.get("_", "") or
-                "PYTEST_CURRENT_TEST" in os.environ or
-                "CI" in os.environ or
-                "GITHUB_ACTIONS" in os.environ or
-                any("test" in arg.lower() for arg in os.sys.argv if hasattr(os, 'sys'))
+                "pytest" in os.environ.get("_", "")
+                or "PYTEST_CURRENT_TEST" in os.environ
+                or "CI" in os.environ
+                or "GITHUB_ACTIONS" in os.environ
+                or any(
+                    "test" in arg.lower() for arg in os.sys.argv if hasattr(os, "sys")
+                )
             )
-            
+
             if is_test_env:
                 log_debug("Test environment detected - allowing temporary file access")
-                
+
                 # Allow access to common temporary directories
                 temp_dirs = [
                     Path(tempfile.gettempdir()).resolve(),
                     Path("/tmp").resolve() if Path("/tmp").exists() else None,
                     Path("/var/tmp").resolve() if Path("/var/tmp").exists() else None,
                 ]
-                
+
                 real_path = Path(file_path).resolve()
                 log_debug(f"Checking test environment access: {real_path}")
-                
+
                 for temp_dir in temp_dirs:
                     if temp_dir and temp_dir.exists():
                         try:
                             real_path.relative_to(temp_dir)
-                            log_debug(f"Path is under temp directory {temp_dir} - allowed in test environment")
+                            log_debug(
+                                f"Path is under temp directory {temp_dir} - allowed in test environment"
+                            )
                             return True, ""
                         except ValueError:
                             continue
-                            
+
                 # In test environment, also allow access to files that start with temp file patterns
                 file_name = Path(file_path).name
-                if (file_name.startswith(("tmp", "temp")) or
-                    "_test_" in file_name or
-                    file_name.endswith(("_test.py", "_test.js", ".tmp"))):
-                    log_debug("Temporary test file pattern detected - allowed in test environment")
+                if (
+                    file_name.startswith(("tmp", "temp"))
+                    or "_test_" in file_name
+                    or file_name.endswith(("_test.py", "_test.js", ".tmp"))
+                ):
+                    log_debug(
+                        "Temporary test file pattern detected - allowed in test environment"
+                    )
                     return True, ""
-            
+
             # Fallback to original temp directory check
             temp_dir = Path(tempfile.gettempdir()).resolve()
             real_path = Path(file_path).resolve()
-            
+
             log_debug(f"Checking test environment access: {real_path} under {temp_dir}")
-            
+
             # Allow access under system temp directory (safe sandbox)
             real_path.relative_to(temp_dir)
-            log_debug("Path is under system temp directory - allowed in test environment")
+            log_debug(
+                "Path is under system temp directory - allowed in test environment"
+            )
             return True, ""
-            
+
         except ValueError:
             return False, "Absolute file paths are not allowed"
         except Exception as e:
@@ -523,45 +550,46 @@ class SecurityValidator:
     def _validate_path_traversal(self, file_path: str) -> tuple[bool, str]:
         """
         Validate file path for directory traversal attempts.
-        
+
         Args:
             file_path: File path to validate
-            
+
         Returns:
             Tuple of (is_valid, error_message)
         """
         norm_path = str(Path(file_path))
-        
+
         # Check for various path traversal patterns
-        traversal_patterns = ["..\\" , "../", ".."]
-        
-        if any(pattern in norm_path for pattern in traversal_patterns[:2]) or norm_path.startswith(traversal_patterns[2]):
+        traversal_patterns = ["..\\", "../", ".."]
+
+        if any(
+            pattern in norm_path for pattern in traversal_patterns[:2]
+        ) or norm_path.startswith(traversal_patterns[2]):
             log_warning(f"Path traversal attempt detected: {file_path} -> {norm_path}")
             return False, "Directory traversal not allowed"
-            
+
         return True, ""
 
-    def _validate_project_boundary(self, file_path: str, base_path: str | None) -> tuple[bool, str]:
+    def _validate_project_boundary(
+        self, file_path: str, base_path: str | None
+    ) -> tuple[bool, str]:
         """
         Validate file path against project boundaries when base_path is provided.
-        
+
         Args:
             file_path: File path to validate
             base_path: Base path for relative path validation
-            
+
         Returns:
             Tuple of (is_valid, error_message)
         """
         if not (self.boundary_manager and base_path):
             return True, ""
-            
+
         norm_path = str(Path(file_path))
         full_path = str(Path(base_path) / norm_path)
-        
+
         if not self.boundary_manager.is_within_project(full_path):
-            return (
-                False,
-                "Access denied. File path must be within project directory"
-            )
-            
+            return (False, "Access denied. File path must be within project directory")
+
         return True, ""

tree_sitter_analyzer/utils/__init__.py

@@ -9,21 +9,23 @@ including tree-sitter API compatibility.
 # Import from tree-sitter compatibility module
 from .tree_sitter_compat import TreeSitterQueryCompat, get_node_text_safe, log_api_info
 
+
 # Re-export logging functions from the parent utils module
 # We need to import these dynamically to avoid circular imports
 def _import_logging_functions():
     """Dynamically import logging functions to avoid circular imports."""
-    import sys
     import importlib.util
     import os
-    
+
     # Import the utils.py file from the parent directory
     parent_dir = os.path.dirname(os.path.dirname(__file__))
-    utils_path = os.path.join(parent_dir, 'utils.py')
-    spec = importlib.util.spec_from_file_location("tree_sitter_analyzer_utils", utils_path)
+    utils_path = os.path.join(parent_dir, "utils.py")
+    spec = importlib.util.spec_from_file_location(
+        "tree_sitter_analyzer_utils", utils_path
+    )
     utils_module = importlib.util.module_from_spec(spec)
     spec.loader.exec_module(utils_module)
-    
+
     return (
         utils_module.setup_logger,
         utils_module.log_debug,
@@ -35,79 +37,107 @@ def _import_logging_functions():
         utils_module.safe_print,
         utils_module.LoggingContext,
         utils_module.setup_performance_logger,
-        utils_module.create_performance_logger
+        utils_module.create_performance_logger,
     )
 
+
 # Import logging functions
 try:
-    setup_logger, log_debug, log_error, log_warning, log_info, log_performance, QuietMode, safe_print, LoggingContext, setup_performance_logger, create_performance_logger = _import_logging_functions()
+    (
+        setup_logger,
+        log_debug,
+        log_error,
+        log_warning,
+        log_info,
+        log_performance,
+        QuietMode,
+        safe_print,
+        LoggingContext,
+        setup_performance_logger,
+        create_performance_logger,
+    ) = _import_logging_functions()
 except Exception:
     # Fallback logging functions if import fails
     def setup_logger(name="tree_sitter_analyzer", level=30):
         import logging
+
         logger = logging.getLogger(name)
         if not logger.handlers:
             handler = logging.StreamHandler()
-            formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+            formatter = logging.Formatter(
+                "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+            )
             handler.setFormatter(formatter)
             logger.addHandler(handler)
         logger.setLevel(level)
         return logger
+
     def log_debug(msg, *args, **kwargs):
         pass
+
     def log_error(msg, *args, **kwargs):
         print(f"ERROR: {msg}", *args)
+
     def log_warning(msg, *args, **kwargs):
         print(f"WARNING: {msg}", *args)
+
     def log_info(msg, *args, **kwargs):
         print(f"INFO: {msg}", *args)
+
     def log_performance(operation, execution_time=None, details=None):
         pass
-    
+
     # Fallback QuietMode class
     class QuietMode:
         def __init__(self, enabled=True):
             self.enabled = enabled
+
         def __enter__(self):
             return self
+
         def __exit__(self, exc_type, exc_val, exc_tb):
             pass
-    
+
     # Fallback LoggingContext class
     class LoggingContext:
         def __init__(self, enabled=True, level=None):
             self.enabled = enabled
             self.level = level
+
         def __enter__(self):
             return self
+
         def __exit__(self, exc_type, exc_val, exc_tb):
             pass
-    
+
     def setup_performance_logger():
         import logging
+
         return logging.getLogger("performance")
-    
+
     def create_performance_logger(name):
         import logging
+
         return logging.getLogger(f"{name}.performance")
-    
+
     def safe_print(message, level="info", quiet=False):
         if not quiet:
             print(message)
 
+
 __all__ = [
-    'TreeSitterQueryCompat',
-    'get_node_text_safe',
-    'log_api_info',
-    'setup_logger',
-    'log_debug',
-    'log_error',
-    'log_warning',
-    'log_info',
-    'log_performance',
-    'QuietMode',
-    'safe_print',
-    'LoggingContext',
-    'setup_performance_logger',
-    'create_performance_logger'
-]
+    "TreeSitterQueryCompat",
+    "get_node_text_safe",
+    "log_api_info",
+    "setup_logger",
+    "log_debug",
+    "log_error",
+    "log_warning",
+    "log_info",
+    "log_performance",
+    "QuietMode",
+    "safe_print",
+    "LoggingContext",
+    "setup_performance_logger",
+    "create_performance_logger",
+]