@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/lsp_orchestrator/src/vds_lsp_orchestrator/models/project_detector.py

@@ -1,646 +0,0 @@
-"""Project detector for identifying formatters, linters, test runners, and other project tools."""
-
-import json
-import logging
-import tomllib
-from dataclasses import dataclass
-from datetime import datetime, timedelta
-from pathlib import Path
-from typing import Literal
-
-# Import enums from models for type annotations
-from vds_lsp_orchestrator.models.project_tools import (
-    FormatterType,
-    LinterType,
-    TestRunnerType,
-)
-
-# Import ProjectTools from utils for the correct dataclass with all fields
-from vds_lsp_orchestrator.utils import ProjectTools
-
-logger = logging.getLogger(__name__)
-
-# Cache configuration
-DEFAULT_CACHE_TIMEOUT_SECONDS = 3600  # 1 hour
-CACHE_DIR_NAME = ".vds-lsp"
-CACHE_SUBDIR_NAME = "cache"
-CACHE_FILE_NAME = "tool_detection.json"
-
-
-@dataclass
-class TestRunnerCache:
-    """Cache entry for test runner detection.
-
-    Attributes:
-        test_runner: The detected test runner
-        source: Where the detection came from (config section, dependency, default)
-        confidence: Detection confidence (high, medium, low)
-        cached_at: When this cache entry was created (ISO format timestamp)
-        pyproject_mtime: Modification time of pyproject.toml when cached
-    """
-
-    test_runner: str
-    source: str
-    confidence: Literal["high", "medium", "low"]
-    cached_at: str
-    pyproject_mtime: float
-
-    def to_dict(self) -> dict:
-        """Convert cache to dictionary for JSON serialization."""
-        return {
-            "test_runner": self.test_runner,
-            "source": self.source,
-            "confidence": self.confidence,
-            "cached_at": self.cached_at,
-            "pyproject_mtime": self.pyproject_mtime,
-        }
-
-    @classmethod
-    def from_dict(cls, data: dict) -> TestRunnerCache:
-        """Create cache entry from dictionary."""
-        return cls(
-            test_runner=data["test_runner"],
-            source=data["source"],
-            confidence=data["confidence"],
-            cached_at=data["cached_at"],
-            pyproject_mtime=data["pyproject_mtime"],
-        )
-
-    def is_valid(
-        self, pyproject_path: Path, timeout_seconds: int = DEFAULT_CACHE_TIMEOUT_SECONDS
-    ) -> bool:
-        """Check if cache entry is still valid.
-
-        Args:
-            pyproject_path: Path to pyproject.toml to check mtime
-            timeout_seconds: Cache timeout in seconds
-
-        Returns:
-            True if cache is valid, False otherwise
-        """
-        # Check file modification time first (more sensitive)
-        if pyproject_path.exists():
-            current_mtime = pyproject_path.stat().st_mtime
-            # Use direct comparison - if mtimes differ at all, invalidate
-            if current_mtime != self.pyproject_mtime:
-                logger.debug(
-                    "Cache invalidated due to file change (cached: %s, current: %s)",
-                    self.pyproject_mtime,
-                    current_mtime,
-                )
-                return False
-
-        # Check age-based timeout
-        try:
-            cached_time = datetime.fromisoformat(self.cached_at)
-            if datetime.now() - cached_time > timedelta(seconds=timeout_seconds):
-                logger.debug("Cache expired due to age")
-                return False
-        except ValueError:
-            logger.warning("Invalid cache timestamp, treating as expired")
-            return False
-
-        return True
-
-
-class ProjectDetector:
-    """Detect project tools and configuration from project structure.
-
-    Test runner detection uses priority order:
-    1. Config sections ([tool.pytest])
-    2. Dependencies (pytest in dependencies)
-    3. Default: unittest (standard library)
-
-    Detection results are cached in .vds-lsp/cache/tool_detection.json
-    and invalidated when pyproject.toml changes or timeout expires.
-    """
-
-    def __init__(
-        self,
-        root_path: Path,
-        cache_timeout_seconds: int = DEFAULT_CACHE_TIMEOUT_SECONDS,
-        cache_dir: Path | None = None,
-    ) -> None:
-        """Initialize the project detector.
-
-        Args:
-            root_path: Root path of the project to analyze. Can be a file or directory.
-            cache_timeout_seconds: How long cache remains valid (default: 1 hour)
-            cache_dir: Optional custom cache directory. If not provided, uses
-                      root_path/.vds-lsp/cache/ (or parent directory if root_path is a file)
-        """
-        self.root_path = Path(root_path).resolve()
-        self._pyproject_data: dict | None = None
-        self.cache_timeout = cache_timeout_seconds
-
-        # Setup cache directory
-        # Resolve paths for consistency but don't use resolve() on custom cache_dir
-        # to preserve the exact path the test expects
-        if cache_dir is not None:
-            self.cache_dir = Path(cache_dir)
-        else:
-            # If root_path is a file, use its parent directory for cache
-            cache_base = self.root_path.parent if self.root_path.is_file() else self.root_path
-            self.cache_dir = cache_base / CACHE_DIR_NAME / CACHE_SUBDIR_NAME
-        self.cache_dir.mkdir(parents=True, exist_ok=True)
-        self.cache_file = self.cache_dir / CACHE_FILE_NAME
-
-    @property
-    def pyproject_toml(self) -> Path | None:
-        """Get the path to pyproject.toml if it exists."""
-        # If root_path is a file, use its parent directory
-        base_path = self.root_path.parent if self.root_path.is_file() else self.root_path
-        path = base_path / "pyproject.toml"
-        return path if path.is_file() else None
-
-    @property
-    def pyproject_data(self) -> dict:
-        """Load and cache pyproject.toml data.
-
-        Returns:
-            Parsed TOML data as dict, or empty dict if file doesn't exist.
-        """
-        if self._pyproject_data is None:
-            self._pyproject_data = self._load_pyproject_toml()
-        return self._pyproject_data
-
-    def _load_pyproject_toml(self) -> dict:
-        """Load pyproject.toml file.
-
-        Returns:
-            Parsed TOML data as dict, or empty dict if file doesn't exist.
-        """
-        if not self.pyproject_toml:
-            return {}
-
-        try:
-            return tomllib.loads(self.pyproject_toml.read_text())
-        except Exception as exc:
-            logger.warning("Failed to parse pyproject.toml: %s", exc)
-            return {}
-
-    def detect(self) -> ProjectTools:
-        """Detect all project tools and configuration.
-
-        Returns:
-            ProjectTools dataclass with detected tools.
-        """
-        # Detect all tools
-        package_manager, _, _ = self._detect_package_manager()
-        type_checker, _, _ = self._detect_type_checker()
-        formatter, _, _ = self._detect_formatter()
-        linter, _, _ = self._detect_linter()
-
-        # Use cached test runner detection (returns just TestRunnerType)
-        test_runner = self._detect_test_runner_with_cache()
-
-        # Detect coverage tool
-        coverage_tool = "coverage" if self._has_dependency("coverage") else "none"
-
-        # Convert enums to strings for utils.ProjectTools
-        return ProjectTools(
-            package_manager=package_manager,
-            type_checker=type_checker,
-            formatter=formatter.value,
-            linter=linter.value,
-            test_runner=test_runner.value,
-            coverage_tool=coverage_tool,
-        )
-
-    def detect_all(self) -> ProjectTools:
-        """Detect all project tools and configuration.
-
-        This is an alias for detect() for backward compatibility with tests.
-
-        Returns:
-            ProjectTools dataclass with detected tools.
-        """
-        return self.detect()
-
-    def _detect_package_manager(
-        self,
-    ) -> tuple[
-        Literal["uv", "poetry", "pdm", "hatch", "pipenv", "pip", "unknown"],
-        str,
-        Literal["high", "medium", "low"],
-    ]:
-        """Detect the package manager from lock files and config.
-
-        Priority order:
-        1. Lock files (uv.lock, poetry.lock, pdm.lock, Pipfile.lock)
-        2. Config sections ([tool.uv], [tool.poetry], etc.)
-        3. Dependencies (project.dependencies)
-        4. Default: pip
-
-        Returns:
-            Tuple of (package_manager, source_description, confidence)
-        """
-        # Priority 1: Check lock files
-        lock_files = [
-            ("uv.lock", "uv"),
-            ("poetry.lock", "poetry"),
-            ("pdm.lock", "pdm"),
-            ("Pipfile.lock", "pipenv"),
-        ]
-
-        for lock_file, manager in lock_files:
-            if (self.root_path / lock_file).exists():
-                logger.debug(f"Detected {manager} from lock file: {lock_file}")
-                return manager, "lock file", "high"
-
-        # Priority 2: Check config sections
-        tool_section = self.pyproject_data.get("tool", {})
-        if "uv" in tool_section:
-            return "uv", "config section", "high"
-        if "poetry" in tool_section:
-            return "poetry", "config section", "high"
-        if "pdm" in tool_section:
-            return "pdm", "config section", "high"
-        if "hatch" in tool_section:
-            return "hatch", "config section", "high"
-
-        # Priority 3: Check dependencies
-        project = self.pyproject_data.get("project", {})
-        dependencies = project.get("dependencies", [])
-        optional_deps = project.get("optional-dependencies", {})
-        all_deps = list(dependencies)
-
-        # Flatten optional dependencies
-        for deps_group in optional_deps.values():
-            if isinstance(deps_group, list):
-                all_deps.extend(deps_group)
-
-        deps_str = " ".join(all_deps).lower()
-
-        # Check for package managers in dependencies
-        if "poetry" in deps_str or "poetry-core" in deps_str:
-            return "poetry", "dependency", "medium"
-        if "pdm" in deps_str:
-            return "pdm", "dependency", "medium"
-        if "hatch" in deps_str or "hatchling" in deps_str:
-            return "hatch", "dependency", "medium"
-        if "uv" in deps_str and "uv-loop" not in deps_str:
-            return "uv", "dependency", "medium"
-
-        # Priority 4: Default to pip
-        logger.debug("No package manager detected, defaulting to pip")
-        return "pip", "default", "low"
-
-    def _detect_type_checker(
-        self,
-    ) -> tuple[
-        Literal["mypy", "basedpyright", "pyright", "none"], str, Literal["high", "medium", "low"]
-    ]:
-        """Detect the type checker from config files and dependencies.
-
-        Priority order:
-        1. Config files (mypy.ini, pyrightconfig.json)
-        2. Config sections ([tool.mypy], [tool.basedpyright], [tool.pyright])
-        3. Dependencies (mypy, basedpyright, pyright)
-        4. Default: basedpyright
-
-        Returns:
-            Tuple of (type_checker, source_description, confidence)
-        """
-        # Priority 1: Check standalone config files
-        mypy_ini = self.root_path / "mypy.ini"
-        pyright_config = self.root_path / "pyrightconfig.json"
-
-        if mypy_ini.exists():
-            return "mypy", "config file", "high"
-        if pyright_config.exists():
-            return "basedpyright", "config file", "high"
-
-        # Priority 2: Check pyproject.toml config sections
-        tool_section = self.pyproject_data.get("tool", {})
-
-        if "mypy" in tool_section:
-            return "mypy", "config section", "high"
-        if "basedpyright" in tool_section:
-            return "basedpyright", "config section", "high"
-        if "pyright" in tool_section:
-            return "pyright", "config section", "high"
-
-        # Priority 3: Check dependencies
-        if self._has_dependency("mypy"):
-            return "mypy", "dependency", "medium"
-        if self._has_dependency("basedpyright"):
-            return "basedpyright", "dependency", "medium"
-        if self._has_dependency("pyright"):
-            return "pyright", "dependency", "medium"
-
-        # Priority 4: Default to basedpyright
-        logger.debug("No type checker detected, defaulting to basedpyright")
-        return "basedpyright", "default", "low"
-
-    def _has_dependency(self, package_name: str) -> bool:
-        """Check if a package is in project dependencies.
-
-        Args:
-            package_name: Name of the package to check (e.g., "pytest", "mypy")
-
-        Returns:
-            True if the package is found in any dependency group
-        """
-        project = self.pyproject_data.get("project", {})
-        dependencies = project.get("dependencies", [])
-        optional_deps = project.get("optional-dependencies", {})
-
-        # Combine all dependency groups
-        all_deps = list(dependencies)
-        for deps_group in optional_deps.values():
-            if isinstance(deps_group, list):
-                all_deps.extend(deps_group)
-
-        # Check dependency groups (uv, pip-tools)
-        dev_groups = self.pyproject_data.get("dependency-groups", {})
-        for group_deps in dev_groups.values():
-            if isinstance(group_deps, list):
-                all_deps.extend(group_deps)
-
-        # Search for the package
-        for dep in all_deps:
-            if not isinstance(dep, str):
-                continue
-
-            # Normalize dependency string
-            dep_lower = dep.lower().strip()
-
-            # Extract package name from spec
-            # Handles: "pytest>=7.0", "pytest==7.0.0", "pytest[all]", etc.
-            name_part = (
-                dep_lower.split(">")[0].split("<")[0].split("=")[0].split("~")[0].split("[")[0]
-            )
-
-            if name_part == package_name.lower():
-                return True
-
-        return False
-
-    def _detect_formatter(self) -> tuple[FormatterType, str, Literal["high", "medium", "low"]]:
-        """Detect the project's formatter from config and dependencies.
-
-        Priority:
-        1. Config sections ([tool.ruff], [tool.black])
-        2. Dependencies (project.dependencies)
-
-        Returns:
-            Tuple of (formatter, source_description, confidence)
-        """
-        # Check config sections first (highest priority)
-        tool_section = self.pyproject_data.get("tool", {})
-
-        if "ruff" in tool_section:
-            return FormatterType.RUFF, "config section", "high"
-
-        if "black" in tool_section:
-            return FormatterType.BLACK, "config section", "high"
-
-        # Check dependencies as fallback
-        project = self.pyproject_data.get("project", {})
-        dependencies = project.get("dependencies", [])
-
-        # Optional dependencies
-        optional_deps = self.pyproject_data.get("project", {}).get("optional-dependencies", {})
-        all_deps = list(dependencies)
-
-        # Flatten optional dependencies
-        for deps_group in optional_deps.values():
-            if isinstance(deps_group, list):
-                all_deps.extend(deps_group)
-
-        # Check for formatters in dependencies
-        for dep in all_deps:
-            if isinstance(dep, str):
-                dep_name = dep.split("=")[0].split(">")[0].split("<")[0].split("~")[0].strip()
-                if dep_name == "ruff":
-                    return FormatterType.RUFF, "dependency", "medium"
-                if dep_name == "black":
-                    return FormatterType.BLACK, "dependency", "medium"
-
-        return FormatterType.NONE, "default", "low"
-
-    def _detect_linter(self) -> tuple[LinterType, str, Literal["high", "medium", "low"]]:
-        """Detect the project's linter from dependencies.
-
-        Priority:
-        1. Dependencies only (no standard config for linters)
-
-        Returns:
-            Tuple of (linter, source_description, confidence)
-        """
-        project = self.pyproject_data.get("project", {})
-        dependencies = project.get("dependencies", [])
-
-        # Optional dependencies
-        optional_deps = self.pyproject_data.get("project", {}).get("optional-dependencies", {})
-        all_deps = list(dependencies)
-
-        # Flatten optional dependencies
-        for deps_group in optional_deps.values():
-            if isinstance(deps_group, list):
-                all_deps.extend(deps_group)
-
-        # Check for linters in dependencies
-        for dep in all_deps:
-            if isinstance(dep, str):
-                dep_name = dep.split("=")[0].split(">")[0].split("<")[0].split("~")[0].strip()
-                if dep_name == "ruff":
-                    return LinterType.RUFF, "dependency", "medium"
-                if dep_name == "pylint":
-                    return LinterType.PYLINT, "dependency", "medium"
-                if dep_name == "flake8":
-                    return LinterType.FLAKE8, "dependency", "medium"
-
-        return LinterType.NONE, "default", "low"
-
-    def _detect_src_layout(self) -> bool:
-        """Detect if the project uses src layout.
-
-        Returns:
-            True if src/ directory exists and contains Python package(s).
-        """
-        src_dir = self.root_path / "src"
-        if not src_dir.is_dir():
-            return False
-
-        # Check for Python packages in src/
-        for item in src_dir.iterdir():
-            if item.is_dir() and not item.name.startswith("."):
-                # Check if it's a Python package (has __init__.py)
-                if (item / "__init__.py").is_file():
-                    return True
-
-        return False
-
-    def _detect_tests(self) -> bool:
-        """Detect if the project has tests.
-
-        Returns:
-            True if tests/ directory exists and contains test files.
-        """
-        tests_dir = self.root_path / "tests"
-        if not tests_dir.is_dir():
-            return False
-
-        # Check for test files (test_*.py or *_test.py)
-        for item in tests_dir.glob("test_*.py"):
-            if item.is_file():
-                return True
-
-        return any(item.is_file() for item in tests_dir.glob("*_test.py"))
-
-    def _detect_test_runner_with_cache(self) -> TestRunnerType:
-        """Detect test runner with caching support.
-
-        Returns:
-            Detected TestRunnerType
-        """
-        pyproject_path = self.pyproject_toml
-
-        # Try to load from cache
-        if self.cache_file.exists():
-            try:
-                cache_data = json.loads(self.cache_file.read_text())
-                cache = TestRunnerCache.from_dict(cache_data)
-
-                if cache.is_valid(pyproject_path or Path(), self.cache_timeout):
-                    logger.debug(
-                        "Using cached test runner detection: %s (source: %s)",
-                        cache.test_runner,
-                        cache.source,
-                    )
-                    return TestRunnerType(cache.test_runner)
-            except (json.JSONDecodeError, KeyError, ValueError) as exc:
-                logger.warning("Failed to load test runner cache: %s", exc)
-
-        # No valid cache, perform detection
-        test_runner, source, confidence = self._detect_test_runner()
-
-        # Save to cache
-        self._save_test_runner_cache(test_runner, source, confidence, pyproject_path or Path())
-
-        return test_runner
-
-    def _detect_test_runner(self) -> tuple[TestRunnerType, str, Literal["high", "medium", "low"]]:
-        """Detect test runner using priority order.
-
-        Priority:
-        1. Config sections ([tool.pytest])
-        2. Dependencies (pytest in dependencies)
-        3. Default: unittest (standard library)
-
-        Returns:
-            Tuple of (test_runner, source_description, confidence)
-        """
-        pyproject_path = self.pyproject_toml
-
-        if not pyproject_path:
-            logger.debug("No pyproject.toml found, defaulting to unittest")
-            return TestRunnerType.UNITTEST, "default (no config file)", "low"
-
-        try:
-            pyproject_data = tomllib.loads(pyproject_path.read_text())
-        except Exception as exc:
-            logger.warning("Failed to parse pyproject.toml: %s", exc)
-            return TestRunnerType.UNITTEST, "default (parse error)", "low"
-
-        # Priority 1: Check [tool.pytest] section
-        tool_section = pyproject_data.get("tool", {})
-        if "pytest" in tool_section:
-            logger.debug("Detected pytest from [tool.pytest] section")
-            return TestRunnerType.PYTEST, "config section", "high"
-
-        # Priority 2: Check dependencies
-        pytest_found = False
-
-        # Check project dependencies
-        project_deps = pyproject_data.get("project", {}).get("dependencies", [])
-        pytest_found = self._has_pytest_in_deps(project_deps)
-
-        # Check optional dependencies
-        if not pytest_found:
-            optional_deps = pyproject_data.get("project", {}).get("optional-dependencies", {})
-            for deps_group in optional_deps.values():
-                if isinstance(deps_group, list) and self._has_pytest_in_deps(deps_group):
-                    pytest_found = True
-                    break
-
-        # Check dependency groups (uv, pip-tools)
-        if not pytest_found:
-            dev_groups = pyproject_data.get("dependency-groups", {})
-            dev_deps = dev_groups.get("dev", [])
-            if isinstance(dev_deps, list) and self._has_pytest_in_deps(dev_deps):
-                pytest_found = True
-
-        if pytest_found:
-            logger.debug("Detected pytest from dependencies")
-            return TestRunnerType.PYTEST, "dependency", "medium"
-
-        # Priority 3: Default to unittest (always available)
-        logger.debug("No pytest detected, defaulting to unittest")
-        return TestRunnerType.UNITTEST, "default (stdlib)", "high"
-
-    def _has_pytest_in_deps(self, deps: list) -> bool:
-        """Check if pytest is in a list of dependency specifications.
-
-        Args:
-            deps: List of dependency strings
-
-        Returns:
-            True if pytest is found
-        """
-        for dep in deps:
-            if not isinstance(dep, str):
-                continue
-            # Normalize for comparison
-            dep_lower = dep.lower().strip()
-            # Check for pytest with various package spec formats
-            # Handles: pytest, pytest>=7.0, pytest==7.0.0, pytest[all], etc.
-            if dep_lower.startswith("pytest"):
-                # Make sure it's not a different package starting with pytest
-                # e.g., pytest-asyncio, pytest-cov
-                name_part = dep_lower.split(">")[0].split("<")[0].split("=")[0].split("[")[0]
-                if name_part == "pytest":
-                    return True
-        return False
-
-    def _save_test_runner_cache(
-        self,
-        runner: TestRunnerType,
-        source: str,
-        confidence: Literal["high", "medium", "low"],
-        pyproject_path: Path,
-    ) -> None:
-        """Save test runner detection to cache.
-
-        Args:
-            runner: The detected test runner
-            source: Source of detection
-            confidence: Confidence level
-            pyproject_path: Path to pyproject.toml for mtime tracking
-        """
-        cache = TestRunnerCache(
-            test_runner=runner.value,
-            source=source,
-            confidence=confidence,
-            cached_at=datetime.now().isoformat(),
-            pyproject_mtime=pyproject_path.stat().st_mtime if pyproject_path.exists() else 0,
-        )
-
-        try:
-            self.cache_file.write_text(json.dumps(cache.to_dict(), indent=2))
-        except Exception as exc:
-            logger.warning("Failed to write test runner cache: %s", exc)
-
-    def invalidate_cache(self) -> None:
-        """Invalidate the detection cache.
-
-        This forces the next detection call to perform fresh detection.
-        """
-        if self.cache_file.exists():
-            try:
-                self.cache_file.unlink()
-                logger.debug("Invalidated tool detection cache")
-            except Exception as exc:
-                logger.warning("Failed to delete cache file: %s", exc)