tree-sitter-analyzer 0.9.9__py3-none-any.whl → 1.1.0__py3-none-any.whl

tree_sitter_analyzer/mcp/utils/path_resolver.py

@@ -9,10 +9,91 @@ operating systems.
 
 import logging
 import os
+from pathlib import Path
 
 logger = logging.getLogger(__name__)
 
 
+def _normalize_path_cross_platform(path_str: str) -> str:
+    """
+    Normalize path for cross-platform compatibility.
+
+    Args:
+        path_str: Input path string
+
+    Returns:
+        Normalized path string
+    """
+    if not path_str:
+        return path_str
+
+    # Handle macOS path normalization issues
+    if os.name == "posix":
+        # Handle /System/Volumes/Data prefix on macOS
+        if path_str.startswith("/System/Volumes/Data/"):
+            # Remove the /System/Volumes/Data prefix
+            normalized = path_str[len("/System/Volumes/Data") :]
+            return normalized
+
+        # Handle /private/var vs /var symlink difference on macOS
+        if path_str.startswith("/private/var/"):
+            # Always normalize to /var form on macOS for consistency
+            var_path = path_str.replace("/private/var/", "/var/", 1)
+            return var_path
+        elif path_str.startswith("/var/"):
+            # Keep /var form as is
+            return path_str
+
+    # Handle Windows short path names (8.3 format)
+    if os.name == "nt" and path_str:
+        try:
+            # Try to get the long path name on Windows
+            import ctypes
+            from ctypes import wintypes
+
+            # GetLongPathNameW function
+            _GetLongPathNameW = ctypes.windll.kernel32.GetLongPathNameW
+            _GetLongPathNameW.argtypes = [
+                wintypes.LPCWSTR,
+                wintypes.LPWSTR,
+                wintypes.DWORD,
+            ]
+            _GetLongPathNameW.restype = wintypes.DWORD
+
+            # Buffer for the long path
+            buffer_size = 1000
+            buffer = ctypes.create_unicode_buffer(buffer_size)
+
+            # Get the long path name
+            result = _GetLongPathNameW(path_str, buffer, buffer_size)
+            if result > 0 and result < buffer_size:
+                long_path = buffer.value
+                if long_path and long_path != path_str:
+                    return long_path
+        except (ImportError, AttributeError, OSError):
+            # If Windows API calls fail, continue with original path
+            pass
+
+    return path_str
+
+
+def _is_windows_absolute_path(path_str: str) -> bool:
+    """
+    Check if a path is a Windows-style absolute path.
+
+    Args:
+        path_str: Path string to check
+
+    Returns:
+        True if it's a Windows absolute path (e.g., C:\\path or C:/path)
+    """
+    if not path_str or len(path_str) < 3:
+        return False
+
+    # Check for drive letter pattern: X:\ or X:/
+    return path_str[1] == ":" and path_str[0].isalpha() and path_str[2] in ("\\", "/")
+
+
 class PathResolver:
     """
     Utility class for resolving file paths in MCP tools.
@@ -28,10 +109,20 @@ class PathResolver:
         Args:
             project_root: Optional project root directory for resolving relative paths
         """
-        self.project_root = project_root
+        self.project_root = None
+        self._cache = {}  # Simple cache for resolved paths
+        self._cache_size_limit = 100  # Limit cache size to prevent memory issues
+
         if project_root:
-            # Normalize project root path
-            self.project_root = os.path.normpath(project_root)
+            # Use pathlib for consistent path handling, but preserve relative paths for compatibility
+            path_obj = Path(project_root)
+            if path_obj.is_absolute():
+                resolved_root = str(path_obj.resolve())
+                # Apply cross-platform normalization
+                self.project_root = _normalize_path_cross_platform(resolved_root)
+            else:
+                # For relative paths, normalize but don't resolve to absolute
+                self.project_root = str(path_obj)
             logger.debug(
                 f"PathResolver initialized with project root: {self.project_root}"
             )
@@ -48,34 +139,126 @@ class PathResolver:
 
         Raises:
             ValueError: If file_path is empty or None
+            TypeError: If file_path is not a string
         """
         if not file_path:
             raise ValueError("file_path cannot be empty or None")
 
-        # If already absolute, return as is
-        if os.path.isabs(file_path):
-            resolved_path = os.path.normpath(file_path)
+        if not isinstance(file_path, str):
+            raise TypeError(
+                f"file_path must be a string, got {type(file_path).__name__}"
+            )
+
+        # Check cache first
+        if file_path in self._cache:
+            logger.debug(f"Cache hit for path: {file_path}")
+            return self._cache[file_path]
+
+        # Normalize path separators first
+        normalized_input = file_path.replace("\\", "/")
+
+        # Special handling for Windows absolute paths on non-Windows systems
+        if _is_windows_absolute_path(file_path) and os.name != "nt":
+            # On non-Windows systems, Windows absolute paths should be treated as-is
+            # Don't try to resolve them relative to project root
+            logger.debug(f"Windows absolute path on non-Windows system: {file_path}")
+            self._add_to_cache(file_path, file_path)
+            return file_path
+
+        path_obj = Path(normalized_input)
+
+        # Handle Unix-style absolute paths on Windows (starting with /) FIRST
+        # This must come before the is_absolute() check because Unix paths aren't
+        # considered absolute on Windows by pathlib
+        if (
+            normalized_input.startswith("/") and os.name == "nt"
+        ):  # Check if we're on Windows
+            # On Windows, convert Unix-style absolute paths to Windows format
+            # by prepending the current drive with proper separator
+            current_drive = Path.cwd().drive
+            if current_drive:
+                # Remove leading slash and join with current drive
+                unix_path_without_slash = normalized_input[1:]
+                # Ensure proper Windows path format with backslash after drive
+                resolved_path = str(
+                    Path(current_drive + "\\") / unix_path_without_slash
+                )
+                logger.debug(
+                    f"Converted Unix absolute path: {file_path} -> {resolved_path}"
+                )
+                # Apply cross-platform normalization
+                resolved_path = _normalize_path_cross_platform(resolved_path)
+                self._add_to_cache(file_path, resolved_path)
+                return resolved_path
+            # If no drive available, continue with normal processing
+
+        # Check if path is absolute
+        if path_obj.is_absolute():
+            resolved_path = str(path_obj.resolve())
             logger.debug(f"Path already absolute: {file_path} -> {resolved_path}")
+            # Apply cross-platform normalization
+            resolved_path = _normalize_path_cross_platform(resolved_path)
+            self._add_to_cache(file_path, resolved_path)
             return resolved_path
 
         # If we have a project root, resolve relative to it
         if self.project_root:
-            resolved_path = os.path.join(self.project_root, file_path)
-            # Normalize path separators for cross-platform compatibility
-            resolved_path = os.path.normpath(resolved_path)
+            resolved_path = str((Path(self.project_root) / normalized_input).resolve())
             logger.debug(
                 f"Resolved relative path '{file_path}' to '{resolved_path}' using project root"
             )
+            # Apply cross-platform normalization
+            resolved_path = _normalize_path_cross_platform(resolved_path)
+            self._add_to_cache(file_path, resolved_path)
             return resolved_path
 
         # Fallback: try to resolve relative to current working directory
-        resolved_path = os.path.abspath(file_path)
-        resolved_path = os.path.normpath(resolved_path)
+        resolved_path = str(Path(normalized_input).resolve())
         logger.debug(
             f"Resolved relative path '{file_path}' to '{resolved_path}' using current working directory"
         )
+
+        # Apply cross-platform normalization
+        resolved_path = _normalize_path_cross_platform(resolved_path)
+
+        # Cache the result
+        self._add_to_cache(file_path, resolved_path)
+
         return resolved_path
 
+    def _add_to_cache(self, file_path: str, resolved_path: str) -> None:
+        """
+        Add a resolved path to the cache.
+
+        Args:
+            file_path: Original file path
+            resolved_path: Resolved absolute path
+        """
+        # Limit cache size to prevent memory issues
+        if len(self._cache) >= self._cache_size_limit:
+            # Remove oldest entries (simple FIFO)
+            oldest_key = next(iter(self._cache))
+            del self._cache[oldest_key]
+            logger.debug(f"Cache full, removed oldest entry: {oldest_key}")
+
+        self._cache[file_path] = resolved_path
+        logger.debug(f"Cached path resolution: {file_path} -> {resolved_path}")
+
+    def clear_cache(self) -> None:
+        """Clear the path resolution cache."""
+        cache_size = len(self._cache)
+        self._cache.clear()
+        logger.info(f"Cleared path resolution cache ({cache_size} entries)")
+
+    def get_cache_stats(self) -> dict[str, int]:
+        """
+        Get cache statistics.
+
+        Returns:
+            Dictionary with cache statistics
+        """
+        return {"size": len(self._cache), "limit": self._cache_size_limit}
+
     def is_relative(self, file_path: str) -> bool:
         """
         Check if a file path is relative.
@@ -86,7 +269,7 @@ class PathResolver:
         Returns:
             True if the path is relative, False if absolute
         """
-        return not os.path.isabs(file_path)
+        return not Path(file_path).is_absolute()
 
     def get_relative_path(self, absolute_path: str) -> str:
         """
@@ -101,15 +284,32 @@ class PathResolver:
         Raises:
             ValueError: If absolute_path is not actually absolute
         """
-        if not os.path.isabs(absolute_path):
+        abs_path = Path(absolute_path)
+        if not abs_path.is_absolute():
             raise ValueError(f"Path is not absolute: {absolute_path}")
 
         if not self.project_root:
             return absolute_path
 
         try:
-            # Get relative path from project root
-            relative_path = os.path.relpath(absolute_path, self.project_root)
+            # Get relative path from project root using pathlib
+            project_path = Path(self.project_root)
+
+            # Normalize both paths for consistent comparison
+            normalized_abs_path = _normalize_path_cross_platform(
+                str(abs_path.resolve())
+            )
+            normalized_project_root = _normalize_path_cross_platform(
+                str(project_path.resolve())
+            )
+
+            # Convert back to Path objects for relative_to calculation
+            normalized_abs_path_obj = Path(normalized_abs_path)
+            normalized_project_root_obj = Path(normalized_project_root)
+
+            relative_path = str(
+                normalized_abs_path_obj.relative_to(normalized_project_root_obj)
+            )
             logger.debug(
                 f"Converted absolute path '{absolute_path}' to relative path '{relative_path}'"
             )
@@ -133,19 +333,31 @@ class PathResolver:
         """
         try:
             resolved_path = self.resolve(file_path)
+            resolved_path_obj = Path(resolved_path)
 
-            # Check if file exists
-            if not os.path.exists(resolved_path):
+            if not resolved_path_obj.exists():
                 return False, f"File does not exist: {resolved_path}"
 
             # Check if it's a file (not directory)
-            if not os.path.isfile(resolved_path):
+            if not resolved_path_obj.is_file():
                 return False, f"Path is not a file: {resolved_path}"
 
+            # Check if it's a symlink (reject symlinks for security)
+            try:
+                if resolved_path_obj.is_symlink():
+                    return False, f"Path is a symlink: {resolved_path}"
+            except (OSError, AttributeError):
+                # is_symlink() might not be available on all platforms
+                # or might fail due to permissions, skip this check
+                pass
+
             # Check if it's within project root (if we have one)
             if self.project_root:
                 try:
-                    os.path.commonpath([resolved_path, self.project_root])
+                    project_path = Path(self.project_root).resolve()
+                    resolved_abs_path = resolved_path_obj.resolve()
+                    # Check if the resolved path is within the project root
+                    resolved_abs_path.relative_to(project_path)
                 except ValueError:
                     return False, f"File path is outside project root: {resolved_path}"
 
@@ -171,7 +383,15 @@ class PathResolver:
             project_root: New project root directory
         """
         if project_root:
-            self.project_root = os.path.normpath(project_root)
+            # Use pathlib for consistent path handling, but preserve relative paths for compatibility
+            path_obj = Path(project_root)
+            if path_obj.is_absolute():
+                resolved_root = str(path_obj.resolve())
+                # Apply cross-platform normalization
+                self.project_root = _normalize_path_cross_platform(resolved_root)
+            else:
+                # For relative paths, normalize but don't resolve to absolute
+                self.project_root = str(path_obj)
             logger.info(f"Project root updated to: {self.project_root}")
         else:
             self.project_root = None

tree_sitter_analyzer/output_manager.py

@@ -120,9 +120,13 @@ class OutputManager:
         """Output supported extensions"""
         if not self.quiet:
             print("Supported file extensions:")
-            for i in range(0, len(extensions), 10):
-                chunk = extensions[i : i + 10]
-                print(f"  {' '.join(chunk)}")
+        # Use more efficient chunking
+        from itertools import islice
+
+        chunk_size = 10
+        for i in range(0, len(extensions), chunk_size):
+            chunk = list(islice(extensions, i, i + chunk_size))
+            print(f"  {' '.join(chunk)}")
             print(f"Total {len(extensions)} extensions supported")
 
     def output_json(self, data: Any) -> None:

tree_sitter_analyzer/project_detector.py

@@ -6,7 +6,7 @@ Intelligent detection of project root directories based on common project marker
 """
 
 import logging
-import os
+from pathlib import Path
 
 logger = logging.getLogger(__name__)
 
@@ -93,13 +93,13 @@ class ProjectRootDetector:
 
         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)
+            abs_path = Path(file_path).resolve()
+            if abs_path.is_file():
+                start_dir = abs_path.parent
             else:
                 start_dir = abs_path
 
-            return self._traverse_upward(start_dir)
+            return self._traverse_upward(str(start_dir))
 
         except Exception as e:
             logger.warning(f"Error detecting project root from {file_path}: {e}")
@@ -113,7 +113,7 @@ class ProjectRootDetector:
             Project root directory path, or None if not detected
         """
         try:
-            return self._traverse_upward(os.getcwd())
+            return self._traverse_upward(str(Path.cwd()))
         except Exception as e:
             logger.warning(f"Error detecting project root from cwd: {e}")
             return None
@@ -128,7 +128,7 @@ class ProjectRootDetector:
         Returns:
             Project root directory path, or None if not found
         """
-        current_dir = os.path.abspath(start_dir)
+        current_dir = str(Path(start_dir).resolve())
         candidates = []
 
         for _depth in range(self.max_depth):
@@ -159,10 +159,11 @@ class ProjectRootDetector:
                     return current_dir
 
             # Move up one directory
-            parent_dir = os.path.dirname(current_dir)
-            if parent_dir == current_dir:  # Reached filesystem root
+            current_path = Path(current_dir)
+            parent_path = current_path.parent
+            if parent_path == current_path:  # Reached filesystem root
                 break
-            current_dir = parent_dir
+            current_dir = str(parent_path)
 
         # Return the best candidate if any found
         if candidates:
@@ -190,19 +191,16 @@ class ProjectRootDetector:
         found_markers = []
 
         try:
-            dir_contents = os.listdir(directory)
+            dir_path = Path(directory)
 
             for marker in PROJECT_MARKERS:
                 if "*" in marker:
-                    # Handle glob patterns
-                    import glob
-
-                    pattern = os.path.join(directory, marker)
-                    if glob.glob(pattern):
+                    # Handle glob patterns using pathlib
+                    if list(dir_path.glob(marker)):
                         found_markers.append(marker)
                 else:
                     # Handle exact matches
-                    if marker in dir_contents:
+                    if (dir_path / marker).exists():
                         found_markers.append(marker)
 
         except (OSError, PermissionError) as e:
@@ -258,15 +256,16 @@ class ProjectRootDetector:
             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()
+            if file_path:
+                path = Path(file_path)
+                if path.exists():
+                    if path.is_file():
+                        return str(path.resolve().parent)
+                    else:
+                        return str(path.resolve())
+            return str(Path.cwd())
         except Exception:
-            return os.getcwd()
+            return str(Path.cwd())
 
 
 def detect_project_root(
@@ -292,9 +291,10 @@ def detect_project_root(
 
     # Priority 1: Explicit root
     if explicit_root:
-        if os.path.exists(explicit_root) and os.path.isdir(explicit_root):
+        explicit_path = Path(explicit_root)
+        if explicit_path.exists() and explicit_path.is_dir():
             logger.debug(f"Using explicit project root: {explicit_root}")
-            return os.path.abspath(explicit_root)
+            return str(explicit_path.resolve())
         else:
             logger.warning(f"Explicit project root does not exist: {explicit_root}")
 

tree_sitter_analyzer/security/boundary_manager.py

@@ -6,7 +6,6 @@ Provides strict project boundary control to prevent access to files
 outside the designated project directory.
 """
 
-import os
 from pathlib import Path
 
 from ..exceptions import SecurityError
@@ -40,14 +39,15 @@ class ProjectBoundaryManager:
         if not project_root:
             raise SecurityError("Project root cannot be empty")
 
-        if not os.path.exists(project_root):
+        project_path = Path(project_root)
+        if not project_path.exists():
             raise SecurityError(f"Project root does not exist: {project_root}")
 
-        if not os.path.isdir(project_root):
+        if not project_path.is_dir():
             raise SecurityError(f"Project root is not a directory: {project_root}")
 
         # Store real path to prevent symlink attacks
-        self.project_root = os.path.realpath(project_root)
+        self.project_root = str(project_path.resolve())
         self.allowed_directories: set[str] = {self.project_root}
 
         log_debug(f"ProjectBoundaryManager initialized with root: {self.project_root}")
@@ -65,13 +65,14 @@ class ProjectBoundaryManager:
         if not directory:
             raise SecurityError("Directory cannot be empty")
 
-        if not os.path.exists(directory):
+        dir_path = Path(directory)
+        if not dir_path.exists():
             raise SecurityError(f"Directory does not exist: {directory}")
 
-        if not os.path.isdir(directory):
+        if not dir_path.is_dir():
             raise SecurityError(f"Path is not a directory: {directory}")
 
-        real_dir = os.path.realpath(directory)
+        real_dir = str(dir_path.resolve())
         self.allowed_directories.add(real_dir)
 
         log_info(f"Added allowed directory: {real_dir}")
@@ -92,16 +93,18 @@ class ProjectBoundaryManager:
                 return False
 
             # Resolve real path to handle symlinks
-            real_path = os.path.realpath(file_path)
+            real_path = str(Path(file_path).resolve())
 
             # Check against all allowed directories
             for allowed_dir in self.allowed_directories:
-                if (
-                    real_path.startswith(allowed_dir + os.sep)
-                    or real_path == allowed_dir
-                ):
+                # Use pathlib to check if path is within allowed directory
+                try:
+                    Path(real_path).relative_to(Path(allowed_dir))
                     log_debug(f"File path within boundaries: {file_path}")
                     return True
+                except ValueError:
+                    # Path is not within this allowed directory, continue checking
+                    continue
 
             log_warning(f"File path outside boundaries: {file_path} -> {real_path}")
             return False
@@ -124,8 +127,14 @@ class ProjectBoundaryManager:
             return None
 
         try:
-            real_path = os.path.realpath(file_path)
-            rel_path = os.path.relpath(real_path, self.project_root)
+            real_path = Path(file_path).resolve()
+            try:
+                rel_path = real_path.relative_to(Path(self.project_root))
+                rel_path = str(rel_path)
+            except ValueError:
+                # Path is not relative to project root
+                log_warning(f"Path not relative to project root: {file_path}")
+                return None
 
             # Ensure relative path doesn't start with ..
             if rel_path.startswith(".."):
@@ -150,17 +159,18 @@ class ProjectBoundaryManager:
         """
         try:
             # Handle relative paths from project root
-            if not os.path.isabs(file_path):
-                full_path = os.path.join(self.project_root, file_path)
+            file_path_obj = Path(file_path)
+            if not file_path_obj.is_absolute():
+                full_path = Path(self.project_root) / file_path
             else:
-                full_path = file_path
+                full_path = file_path_obj
 
             # Check boundaries
-            if not self.is_within_project(full_path):
+            if not self.is_within_project(str(full_path)):
                 return None
 
             # Return real path
-            return os.path.realpath(full_path)
+            return str(full_path.resolve())
 
         except Exception as e:
             log_warning(f"Path validation error: {e}")
@@ -186,28 +196,27 @@ class ProjectBoundaryManager:
             True if path is safe from symlink attacks
         """
         try:
-            if not os.path.exists(file_path):
+            file_path_obj = Path(file_path)
+            if not file_path_obj.exists():
                 return True  # Non-existent files are safe
 
             # If the fully resolved path is within project boundaries, we treat it as safe.
             # This makes the check tolerant to system-level symlinks like
             # /var -> /private/var on macOS runners.
-            resolved = os.path.realpath(file_path)
+            resolved = str(file_path_obj.resolve())
             if self.is_within_project(resolved):
                 return True
 
             # Otherwise, inspect each path component symlink to ensure no hop jumps outside
             # the allowed directories.
-            path_parts = Path(file_path).parts
-            current_path = ""
+            path_parts = file_path_obj.parts
+            current_path = Path()
 
             for part in path_parts:
-                current_path = (
-                    os.path.join(current_path, part) if current_path else part
-                )
+                current_path = current_path / part if current_path.parts else Path(part)
 
-                if os.path.islink(current_path):
-                    target = os.path.realpath(current_path)
+                if current_path.is_symlink():
+                    target = str(current_path.resolve())
                     if not self.is_within_project(target):
                         log_warning(
                             f"Unsafe symlink detected: {current_path} -> {target}"