tree-sitter-analyzer 0.9.2__py3-none-any.whl → 0.9.4__py3-none-any.whl

tree_sitter_analyzer/project_detector.py

@@ -1,317 +1,330 @@
-#!/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}")
+#!/usr/bin/env python3
+"""
+Project Root Detection
+
+Intelligent detection of project root directories based on common project markers.
+"""
+
+import logging
+import os
+
+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) -> str | None:
+        """
+        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) -> str | None:
+        """
+        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) -> str | None:
+        """
+        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: str | None = None, explicit_root: str | None = 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.debug(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.debug(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.debug(f"Auto-detected project root from cwd: {detected_root}")
+        return detected_root
+
+    # Priority 4: Fallback
+    fallback_root = detector.get_fallback_root(file_path)
+    logger.debug(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}")