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

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/queries/__init__.py

@@ -1,26 +1,26 @@
-#!/usr/bin/env python3
-"""
-Language-specific Tree-sitter queries package.
-
-This package provides Tree-sitter queries for various programming languages.
-Each language has its own module with predefined queries for common code elements.
-
-Supported languages:
-- Java
-- JavaScript
-- Python
-- TypeScript
-
-Usage:
-    from tree_sitter_analyzer.queries import get_query, list_queries
-
-    # Get a specific query
-    query = get_query('java', 'classes')
-
-    # List all queries for a language
-    queries = list_queries('python')
-"""
-
-from ..query_loader import get_query, is_language_supported, list_queries, query_loader
-
-__all__ = ["get_query", "list_queries", "is_language_supported", "query_loader"]
+#!/usr/bin/env python3
+"""
+Language-specific Tree-sitter queries package.
+
+This package provides Tree-sitter queries for various programming languages.
+Each language has its own module with predefined queries for common code elements.
+
+Supported languages:
+- Java
+- JavaScript
+- Python
+- TypeScript
+
+Usage:
+    from tree_sitter_analyzer.queries import get_query, list_queries
+
+    # Get a specific query
+    query = get_query('java', 'classes')
+
+    # List all queries for a language
+    queries = list_queries('python')
+"""
+
+from ..query_loader import get_query, is_language_supported, list_queries, query_loader
+
+__all__ = ["get_query", "list_queries", "is_language_supported", "query_loader"]