tree-sitter-analyzer 1.9.17.1__py3-none-any.whl

tree_sitter_analyzer/plugins/manager.py

@@ -0,0 +1,384 @@
+#!/usr/bin/env python3
+"""
+Plugin Manager
+
+Dynamic plugin discovery and management system.
+Handles loading plugins from entry points and local directories.
+"""
+
+import importlib
+import importlib.metadata
+import logging
+import pkgutil
+from pathlib import Path
+from typing import Any
+
+from ..utils import log_debug, log_error, log_info, log_warning
+from .base import LanguagePlugin
+
+logger = logging.getLogger(__name__)
+
+
+class PluginManager:
+    """
+    Manages dynamic discovery and loading of language plugins.
+
+    This class handles:
+    - Discovery of plugins via entry points
+    - Loading plugins from local directories
+    - Plugin lifecycle management
+    - Error handling and fallback mechanisms
+    """
+
+    def __init__(self) -> None:
+        """Initialize the plugin manager."""
+        self._loaded_plugins: dict[str, LanguagePlugin] = {}
+        self._plugin_classes: dict[str, type[LanguagePlugin]] = {}
+        self._entry_point_group = "tree_sitter_analyzer.plugins"
+
+    def load_plugins(self) -> list[LanguagePlugin]:
+        """
+        Load all available plugins from various sources.
+
+        Returns:
+            List of successfully loaded plugin instances
+        """
+        loaded_plugins = []
+
+        # Load plugins from entry points (installed packages)
+        entry_point_plugins = self._load_from_entry_points()
+        loaded_plugins.extend(entry_point_plugins)
+
+        # Load plugins from local languages directory
+        local_plugins = self._load_from_local_directory()
+        loaded_plugins.extend(local_plugins)
+
+        # Store loaded plugins and deduplicate by language
+        unique_plugins = {}
+        for plugin in loaded_plugins:
+            language = plugin.get_language_name()
+            if language not in unique_plugins:
+                unique_plugins[language] = plugin
+                self._loaded_plugins[language] = plugin
+            else:
+                log_debug(f"Skipping duplicate plugin for language: {language}")
+
+        final_plugins = list(unique_plugins.values())
+        # Only log if not in CLI mode (check if we're in quiet mode)
+        import os
+
+        log_level = os.environ.get("LOG_LEVEL", "WARNING")
+        if log_level != "ERROR":
+            log_info(f"Successfully loaded {len(final_plugins)} plugins")
+        return final_plugins
+
+    def _load_from_entry_points(self) -> list[LanguagePlugin]:
+        """
+        Load plugins from setuptools entry points.
+
+        Returns:
+            List of plugin instances loaded from entry points
+        """
+        plugins = []
+
+        try:
+            # Get entry points for our plugin group
+            entry_points = importlib.metadata.entry_points()
+
+            # Handle both old and new entry_points API
+            plugin_entries: Any = []
+            if hasattr(entry_points, "select"):
+                # New API (Python 3.10+)
+                plugin_entries = entry_points.select(group=self._entry_point_group)
+            else:
+                # Old API - handle different return types
+                try:
+                    # Try to get entry points, handling different API versions
+                    if hasattr(entry_points, "get"):
+                        result = entry_points.get(self._entry_point_group)
+                        plugin_entries = list(result) if result else []
+                    else:
+                        plugin_entries = []
+                except (TypeError, AttributeError):
+                    # Fallback for incompatible entry_points types
+                    plugin_entries = []
+
+            for entry_point in plugin_entries:
+                try:
+                    # Load the plugin class
+                    plugin_class = entry_point.load()
+
+                    # Validate it's a LanguagePlugin
+                    if not issubclass(plugin_class, LanguagePlugin):
+                        log_warning(
+                            f"Entry point {entry_point.name} is not a LanguagePlugin"
+                        )
+                        continue
+
+                    # Create instance
+                    plugin_instance = plugin_class()
+                    plugins.append(plugin_instance)
+
+                    log_debug(f"Loaded plugin from entry point: {entry_point.name}")
+
+                except Exception as e:
+                    log_error(
+                        f"Failed to load plugin from entry point {entry_point.name}: {e}"
+                    )
+
+        except Exception as e:
+            log_warning(f"Failed to load plugins from entry points: {e}")
+
+        return plugins
+
+    def _load_from_local_directory(self) -> list[LanguagePlugin]:
+        """
+        Load plugins from the local languages directory.
+
+        Returns:
+            List of plugin instances loaded from local directory
+        """
+        plugins: list[LanguagePlugin] = []
+
+        try:
+            # Get the languages directory path
+            current_dir = Path(__file__).parent.parent
+            languages_dir = current_dir / "languages"
+
+            if not languages_dir.exists():
+                log_debug("Languages directory does not exist, creating it")
+                languages_dir.mkdir(exist_ok=True)
+                # Create __init__.py
+                (languages_dir / "__init__.py").touch()
+                return plugins
+
+            # Import the languages package
+            languages_package = "tree_sitter_analyzer.languages"
+
+            try:
+                languages_module = importlib.import_module(languages_package)
+            except ImportError as e:
+                log_warning(f"Could not import languages package: {e}")
+                return plugins
+
+            # Discover plugin modules in the languages directory
+            for _finder, name, ispkg in pkgutil.iter_modules(
+                languages_module.__path__, languages_module.__name__ + "."
+            ):
+                if ispkg:
+                    continue
+
+                try:
+                    # Import the module
+                    module = importlib.import_module(name)
+
+                    # Look for LanguagePlugin classes
+                    plugin_classes = self._find_plugin_classes(module)
+
+                    for plugin_class in plugin_classes:
+                        try:
+                            plugin_instance = plugin_class()
+                            plugins.append(plugin_instance)
+                            log_debug(f"Loaded local plugin: {plugin_class.__name__}")
+                        except Exception as e:
+                            log_error(
+                                f"Failed to instantiate plugin {plugin_class.__name__}: {e}"
+                            )
+
+                except Exception as e:
+                    log_error(f"Failed to load plugin module {name}: {e}")
+
+        except Exception as e:
+            log_warning(f"Failed to load plugins from local directory: {e}")
+
+        return plugins
+
+    def _find_plugin_classes(self, module: Any) -> list[type[LanguagePlugin]]:
+        """
+        Find LanguagePlugin classes in a module.
+
+        Args:
+            module: Python module to search
+
+        Returns:
+            List of LanguagePlugin classes found in the module
+        """
+        plugin_classes: list[type[LanguagePlugin]] = []
+
+        for attr_name in dir(module):
+            attr = getattr(module, attr_name)
+
+            # Check if it's a class and subclass of LanguagePlugin
+            if (
+                isinstance(attr, type)
+                and issubclass(attr, LanguagePlugin)
+                and attr is not LanguagePlugin
+            ):
+                plugin_classes.append(attr)
+
+        return plugin_classes
+
+    def get_plugin(self, language: str) -> LanguagePlugin | None:
+        """
+        Get a plugin for a specific language.
+
+        Args:
+            language: Programming language name
+
+        Returns:
+            Plugin instance or None if not found
+        """
+        return self._loaded_plugins.get(language)
+
+    def get_all_plugins(self) -> dict[str, LanguagePlugin]:
+        """
+        Get all loaded plugins.
+
+        Returns:
+            Dictionary mapping language names to plugin instances
+        """
+        return self._loaded_plugins.copy()
+
+    def get_supported_languages(self) -> list[str]:
+        """
+        Get list of all supported languages.
+
+        Returns:
+            List of supported language names
+        """
+        return list(self._loaded_plugins.keys())
+
+    def reload_plugins(self) -> list[LanguagePlugin]:
+        """
+        Reload all plugins (useful for development).
+
+        Returns:
+            List of reloaded plugin instances
+        """
+        log_info("Reloading all plugins")
+
+        # Clear existing plugins
+        self._loaded_plugins.clear()
+        self._plugin_classes.clear()
+
+        # Reload
+        return self.load_plugins()
+
+    def register_plugin(self, plugin: LanguagePlugin) -> bool:
+        """
+        Manually register a plugin instance.
+
+        Args:
+            plugin: Plugin instance to register
+
+        Returns:
+            True if registration was successful
+        """
+        try:
+            language = plugin.get_language_name()
+
+            if language in self._loaded_plugins:
+                log_warning(
+                    f"Plugin for language '{language}' already exists, replacing"
+                )
+
+            self._loaded_plugins[language] = plugin
+            log_debug(f"Manually registered plugin for language: {language}")
+            return True
+
+        except Exception as e:
+            log_error(f"Failed to register plugin: {e}")
+            return False
+
+    def unregister_plugin(self, language: str) -> bool:
+        """
+        Unregister a plugin for a specific language.
+
+        Args:
+            language: Programming language name
+
+        Returns:
+            True if unregistration was successful
+        """
+        if language in self._loaded_plugins:
+            del self._loaded_plugins[language]
+            log_debug(f"Unregistered plugin for language: {language}")
+            return True
+
+        return False
+
+    def get_plugin_info(self, language: str) -> dict[str, Any] | None:
+        """
+        Get information about a specific plugin.
+
+        Args:
+            language: Programming language name
+
+        Returns:
+            Plugin information dictionary or None
+        """
+        plugin = self.get_plugin(language)
+        if not plugin:
+            return None
+
+        try:
+            return {
+                "language": plugin.get_language_name(),
+                "extensions": plugin.get_file_extensions(),
+                "class_name": plugin.__class__.__name__,
+                "module": plugin.__class__.__module__,
+                "has_extractor": hasattr(plugin, "create_extractor"),
+            }
+        except Exception as e:
+            log_error(f"Failed to get plugin info for {language}: {e}")
+            return None
+
+    def validate_plugin(self, plugin: LanguagePlugin) -> bool:
+        """
+        Validate that a plugin implements the required interface correctly.
+
+        Args:
+            plugin: Plugin instance to validate
+
+        Returns:
+            True if the plugin is valid
+        """
+        try:
+            # Check required methods
+            required_methods = [
+                "get_language_name",
+                "get_file_extensions",
+                "create_extractor",
+            ]
+
+            for method_name in required_methods:
+                if not hasattr(plugin, method_name):
+                    log_error(f"Plugin missing required method: {method_name}")
+                    return False
+
+                method = getattr(plugin, method_name)
+                if not callable(method):
+                    log_error(f"Plugin method {method_name} is not callable")
+                    return False
+
+            # Test basic functionality
+            language = plugin.get_language_name()
+            if not language or not isinstance(language, str):
+                log_error("Plugin get_language_name() must return a non-empty string")
+                return False
+
+            extensions = plugin.get_file_extensions()
+            if not isinstance(extensions, list):
+                log_error("Plugin get_file_extensions() must return a list")  # type: ignore[unreachable]
+                return False
+
+            extractor = plugin.create_extractor()
+            if not extractor:
+                log_error("Plugin create_extractor() must return an extractor instance")
+                return False
+
+            return True
+
+        except Exception as e:
+            log_error(f"Plugin validation failed: {e}")
+            return False

tree_sitter_analyzer/project_detector.py

@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+"""
+Project Root Detection
+
+Intelligent detection of project root directories based on common project markers.
+"""
+
+import logging
+from pathlib import Path
+
+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",
+    ".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 = Path(file_path).resolve()
+            if abs_path.is_file():
+                start_dir = abs_path.parent
+            else:
+                start_dir = abs_path
+
+            return self._traverse_upward(str(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(str(Path.cwd()))
+        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 = str(Path(start_dir).resolve())
+        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
+            current_path = Path(current_dir)
+            parent_path = current_path.parent
+            if parent_path == current_path:  # Reached filesystem root
+                break
+            current_dir = str(parent_path)
+
+        # 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_path = Path(directory)
+
+            for marker in PROJECT_MARKERS:
+                if "*" in marker:
+                    # Handle glob patterns using pathlib
+                    if list(dir_path.glob(marker)):
+                        found_markers.append(marker)
+                else:
+                    # Handle exact matches
+                    if (dir_path / marker).exists():
+                        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:
+                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 str(Path.cwd())
+
+
+def detect_project_root(
+    file_path: str | None = None, explicit_root: str | None = None
+) -> str | None:
+    """
+    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. Return None if no markers found
+
+    Args:
+        file_path: Path to a file within the project
+        explicit_root: Explicitly specified project root
+
+    Returns:
+        Project root directory path, or None if no markers found
+    """
+    detector = ProjectRootDetector()
+
+    # Priority 1: Explicit root
+    if 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 str(explicit_path.resolve())
+        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: Return None if no markers found
+    logger.debug("No project markers found, returning None")
+    return None
+
+
+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}")