lucidscan 0.5.12__py3-none-any.whl

lucidscan/plugins/type_checkers/pyright.py

@@ -0,0 +1,313 @@
+"""pyright type checker plugin.
+
+pyright is a fast static type checker for Python.
+https://github.com/microsoft/pyright
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import platform
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from lucidscan.bootstrap.paths import LucidscanPaths
+from lucidscan.bootstrap.versions import get_tool_version
+from lucidscan.core.logging import get_logger
+from lucidscan.core.models import (
+    ScanContext,
+    Severity,
+    ToolDomain,
+    UnifiedIssue,
+)
+from lucidscan.plugins.type_checkers.base import TypeCheckerPlugin
+
+LOGGER = get_logger(__name__)
+
+# Default version from pyproject.toml [tool.lucidscan.tools]
+DEFAULT_VERSION = get_tool_version("pyright")
+
+# pyright severity mapping
+SEVERITY_MAP = {
+    "error": Severity.HIGH,
+    "warning": Severity.MEDIUM,
+    "information": Severity.LOW,
+}
+
+
+class PyrightChecker(TypeCheckerPlugin):
+    """pyright type checker plugin for Python code analysis."""
+
+    def __init__(
+        self,
+        version: str = DEFAULT_VERSION,
+        project_root: Optional[Path] = None,
+    ):
+        """Initialize PyrightChecker.
+
+        Args:
+            version: pyright version to use.
+            project_root: Optional project root for tool installation.
+        """
+        self._version = version
+        if project_root:
+            self._paths = LucidscanPaths.for_project(project_root)
+            self._project_root = project_root
+        else:
+            self._paths = LucidscanPaths.default()
+            self._project_root = None
+
+    @property
+    def name(self) -> str:
+        """Plugin identifier."""
+        return "pyright"
+
+    @property
+    def languages(self) -> List[str]:
+        """Supported languages."""
+        return ["python"]
+
+    @property
+    def supports_strict_mode(self) -> bool:
+        """pyright supports strict mode."""
+        return True
+
+    def get_version(self) -> str:
+        """Get pyright version."""
+        return self._version
+
+    def ensure_binary(self) -> Path:
+        """Ensure pyright is available.
+
+        Checks for pyright in:
+        1. Project's .venv/bin/pyright (pip installed pyright)
+        2. Project's node_modules/.bin/pyright
+        3. System PATH (npm or pip installed)
+        4. Downloads standalone binary if not found
+
+        Returns:
+            Path to pyright binary.
+        """
+        # Check project venv first (pip install pyright)
+        if self._project_root:
+            venv_pyright = self._project_root / ".venv" / "bin" / "pyright"
+            if venv_pyright.exists():
+                return venv_pyright
+
+        # Check project node_modules
+        if self._project_root:
+            node_pyright = self._project_root / "node_modules" / ".bin" / "pyright"
+            if node_pyright.exists():
+                return node_pyright
+
+        # Check system PATH (npm or pip installed)
+        pyright_path = shutil.which("pyright")
+        if pyright_path:
+            return Path(pyright_path)
+
+        # Download standalone binary
+        return self._download_binary()
+
+    def _download_binary(self) -> Path:
+        """Download pyright standalone binary.
+
+        Returns:
+            Path to downloaded binary.
+        """
+
+        binary_dir = self._paths.plugin_bin_dir(self.name, self._version)
+        binary_name = "pyright.exe" if platform.system() == "Windows" else "pyright"
+        binary_path = binary_dir / binary_name
+
+        if binary_path.exists():
+            return binary_path
+
+        LOGGER.info(f"Downloading pyright {self._version}...")
+        binary_dir.mkdir(parents=True, exist_ok=True)
+
+        # pyright is distributed as npm package, but we can use pyright-python
+        # which provides a standalone binary
+        # For now, we'll check if pyright is available via pip
+        pip_pyright = shutil.which("pyright")
+        if pip_pyright:
+            return Path(pip_pyright)
+
+        # If not available, try to use npm to install it locally
+        # or raise an error with installation instructions
+        raise FileNotFoundError(
+            "pyright is not installed. Install it with:\n"
+            "  npm install -g pyright\n"
+            "  OR\n"
+            "  pip install pyright"
+        )
+
+    def check(self, context: ScanContext) -> List[UnifiedIssue]:
+        """Run pyright type checking.
+
+        Args:
+            context: Scan context with paths and configuration.
+
+        Returns:
+            List of type checking issues.
+        """
+        try:
+            binary = self.ensure_binary()
+        except FileNotFoundError as e:
+            LOGGER.warning(str(e))
+            return []
+
+        # Build command
+        cmd = [
+            str(binary),
+            "--outputjson",
+        ]
+
+        # Add paths to check
+        paths = [str(p) for p in context.paths] if context.paths else ["."]
+        cmd.extend(paths)
+
+        LOGGER.debug(f"Running: {' '.join(cmd)}")
+
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                cwd=str(context.project_root),
+                timeout=180,  # 3 minute timeout
+            )
+        except subprocess.TimeoutExpired:
+            LOGGER.warning("pyright timed out after 180 seconds")
+            return []
+        except Exception as e:
+            LOGGER.error(f"Failed to run pyright: {e}")
+            return []
+
+        # Parse output
+        issues = self._parse_output(result.stdout, context.project_root)
+
+        LOGGER.info(f"pyright found {len(issues)} issues")
+        return issues
+
+    def _parse_output(self, output: str, project_root: Path) -> List[UnifiedIssue]:
+        """Parse pyright JSON output.
+
+        Args:
+            output: JSON output from pyright.
+            project_root: Project root directory.
+
+        Returns:
+            List of UnifiedIssue objects.
+        """
+        if not output.strip():
+            return []
+
+        try:
+            data = json.loads(output)
+        except json.JSONDecodeError:
+            LOGGER.warning("Failed to parse pyright output as JSON")
+            return []
+
+        issues = []
+        diagnostics = data.get("generalDiagnostics", [])
+
+        for diagnostic in diagnostics:
+            issue = self._diagnostic_to_issue(diagnostic, project_root)
+            if issue:
+                issues.append(issue)
+
+        return issues
+
+    def _diagnostic_to_issue(
+        self,
+        diagnostic: Dict[str, Any],
+        project_root: Path,
+    ) -> Optional[UnifiedIssue]:
+        """Convert pyright diagnostic to UnifiedIssue.
+
+        Args:
+            diagnostic: pyright diagnostic dict.
+            project_root: Project root directory.
+
+        Returns:
+            UnifiedIssue or None.
+        """
+        try:
+            severity_str = diagnostic.get("severity", "error")
+            message = diagnostic.get("message", "")
+            file = diagnostic.get("file", "")
+            rule = diagnostic.get("rule", "")
+
+            # Get range info
+            range_info = diagnostic.get("range", {})
+            start = range_info.get("start", {})
+            end = range_info.get("end", {})
+
+            line_start = start.get("line", 0) + 1  # pyright uses 0-based lines
+            line_end = end.get("line", 0) + 1
+            column = start.get("character", 0) + 1
+
+            # Get severity
+            severity = SEVERITY_MAP.get(severity_str, Severity.MEDIUM)
+
+            # Build file path
+            file_path = Path(file)
+            if not file_path.is_absolute():
+                file_path = project_root / file_path
+
+            # Generate deterministic ID
+            issue_id = self._generate_issue_id(rule, file, line_start, column, message)
+
+            # Build title
+            title = f"[{rule}] {message}" if rule else message
+
+            return UnifiedIssue(
+                id=issue_id,
+                domain=ToolDomain.TYPE_CHECKING,
+                source_tool="pyright",
+                severity=severity,
+                rule_id=rule or "unknown",
+                title=title,
+                description=message,
+                documentation_url="https://github.com/microsoft/pyright/blob/main/docs/configuration.md",
+                file_path=file_path,
+                line_start=line_start,
+                line_end=line_end,
+                column_start=column,
+                fixable=False,
+                metadata={
+                    "severity_raw": severity_str,
+                },
+            )
+        except Exception as e:
+            LOGGER.warning(f"Failed to parse pyright diagnostic: {e}")
+            return None
+
+    def _generate_issue_id(
+        self,
+        rule: str,
+        file: str,
+        line: int,
+        column: int,
+        message: str,
+    ) -> str:
+        """Generate deterministic issue ID.
+
+        Args:
+            rule: Error rule/code.
+            file: File path.
+            line: Line number.
+            column: Column number.
+            message: Error message.
+
+        Returns:
+            Unique issue ID.
+        """
+        content = f"{rule}:{file}:{line}:{column}:{message}"
+        hash_val = hashlib.sha256(content.encode()).hexdigest()[:12]
+        return f"pyright-{rule}-{hash_val}" if rule else f"pyright-{hash_val}"

lucidscan/plugins/type_checkers/typescript.py

@@ -0,0 +1,280 @@
+"""TypeScript type checker plugin.
+
+TypeScript uses the tsc compiler for type checking.
+https://www.typescriptlang.org/
+"""
+
+from __future__ import annotations
+
+import hashlib
+import re
+import shutil
+import subprocess
+from pathlib import Path
+from typing import List, Optional
+
+from lucidscan.core.logging import get_logger
+from lucidscan.core.models import (
+    ScanContext,
+    Severity,
+    ToolDomain,
+    UnifiedIssue,
+)
+from lucidscan.plugins.type_checkers.base import TypeCheckerPlugin
+
+LOGGER = get_logger(__name__)
+
+# TypeScript error pattern: file(line,col): error TS1234: message
+TSC_ERROR_PATTERN = re.compile(
+    r"^(.+?)\((\d+),(\d+)\):\s+(error|warning)\s+(TS\d+):\s+(.+)$"
+)
+
+
+class TypeScriptChecker(TypeCheckerPlugin):
+    """TypeScript type checker plugin using tsc."""
+
+    def __init__(self, project_root: Optional[Path] = None):
+        """Initialize TypeScriptChecker.
+
+        Args:
+            project_root: Optional project root for finding tsc installation.
+        """
+        self._project_root = project_root
+
+    @property
+    def name(self) -> str:
+        """Plugin identifier."""
+        return "typescript"
+
+    @property
+    def languages(self) -> List[str]:
+        """Supported languages."""
+        return ["typescript"]
+
+    @property
+    def supports_strict_mode(self) -> bool:
+        """TypeScript supports strict mode via tsconfig.json."""
+        return True
+
+    def get_version(self) -> str:
+        """Get TypeScript version.
+
+        Returns:
+            Version string or 'unknown' if unable to determine.
+        """
+        try:
+            binary = self.ensure_binary()
+            result = subprocess.run(
+                [str(binary), "--version"],
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                timeout=30,
+            )
+            # Output is like "Version 5.3.3"
+            if result.returncode == 0:
+                parts = result.stdout.strip().split()
+                if len(parts) >= 2:
+                    return parts[1]
+        except Exception:
+            pass
+        return "unknown"
+
+    def ensure_binary(self) -> Path:
+        """Ensure tsc is available.
+
+        Checks for tsc in:
+        1. Project's node_modules/.bin/tsc
+        2. System PATH (globally installed)
+
+        Returns:
+            Path to tsc binary.
+
+        Raises:
+            FileNotFoundError: If TypeScript is not installed.
+        """
+        # Check project node_modules first
+        if self._project_root:
+            node_tsc = self._project_root / "node_modules" / ".bin" / "tsc"
+            if node_tsc.exists():
+                return node_tsc
+
+        # Check system PATH
+        tsc_path = shutil.which("tsc")
+        if tsc_path:
+            return Path(tsc_path)
+
+        raise FileNotFoundError(
+            "TypeScript is not installed. Install it with:\n"
+            "  npm install typescript --save-dev\n"
+            "  OR\n"
+            "  npm install -g typescript"
+        )
+
+    def check(self, context: ScanContext) -> List[UnifiedIssue]:
+        """Run TypeScript type checking.
+
+        Args:
+            context: Scan context with paths and configuration.
+
+        Returns:
+            List of type checking issues.
+        """
+        try:
+            binary = self.ensure_binary()
+        except FileNotFoundError as e:
+            LOGGER.warning(str(e))
+            return []
+
+        # Check for tsconfig.json
+        tsconfig = context.project_root / "tsconfig.json"
+        if not tsconfig.exists():
+            LOGGER.warning(
+                f"No tsconfig.json found in {context.project_root}, skipping TypeScript checking"
+            )
+            return []
+
+        # Build command
+        cmd = [
+            str(binary),
+            "--noEmit",       # Don't emit compiled files
+            "--pretty", "false",  # Plain output for parsing
+        ]
+
+        LOGGER.debug(f"Running: {' '.join(cmd)}")
+
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                cwd=str(context.project_root),
+                timeout=180,  # 3 minute timeout
+            )
+        except subprocess.TimeoutExpired:
+            LOGGER.warning("tsc timed out after 180 seconds")
+            return []
+        except Exception as e:
+            LOGGER.error(f"Failed to run tsc: {e}")
+            return []
+
+        # Parse output (tsc outputs to stdout on success, stderr on error)
+        output = result.stdout or result.stderr
+        issues = self._parse_output(output, context.project_root)
+
+        LOGGER.info(f"TypeScript found {len(issues)} issues")
+        return issues
+
+    def _parse_output(self, output: str, project_root: Path) -> List[UnifiedIssue]:
+        """Parse tsc output.
+
+        tsc outputs errors in format:
+        file(line,col): error TS1234: message
+
+        Args:
+            output: Output from tsc command.
+            project_root: Project root directory.
+
+        Returns:
+            List of UnifiedIssue objects.
+        """
+        if not output.strip():
+            return []
+
+        issues = []
+        for line in output.strip().split("\n"):
+            line = line.strip()
+            if not line:
+                continue
+
+            match = TSC_ERROR_PATTERN.match(line)
+            if match:
+                issue = self._match_to_issue(match, project_root)
+                if issue:
+                    issues.append(issue)
+            else:
+                LOGGER.debug(f"Skipping non-matching line: {line}")
+
+        return issues
+
+    def _match_to_issue(
+        self,
+        match: re.Match,
+        project_root: Path,
+    ) -> Optional[UnifiedIssue]:
+        """Convert regex match to UnifiedIssue.
+
+        Args:
+            match: Regex match from TSC_ERROR_PATTERN.
+            project_root: Project root directory.
+
+        Returns:
+            UnifiedIssue or None.
+        """
+        try:
+            file_path_str = match.group(1)
+            line = int(match.group(2))
+            column = int(match.group(3))
+            severity_str = match.group(4)
+            code = match.group(5)
+            message = match.group(6)
+
+            # TypeScript errors are always high severity
+            severity = Severity.HIGH if severity_str == "error" else Severity.MEDIUM
+
+            # Build file path
+            file_path = Path(file_path_str)
+            if not file_path.is_absolute():
+                file_path = project_root / file_path
+
+            # Generate deterministic ID
+            issue_id = self._generate_issue_id(code, file_path_str, line, column, message)
+
+            return UnifiedIssue(
+                id=issue_id,
+                domain=ToolDomain.TYPE_CHECKING,
+                source_tool="typescript",
+                severity=severity,
+                rule_id=code,
+                title=f"[{code}] {message}",
+                description=message,
+                documentation_url=f"https://typescript.tv/errors/#{code}",
+                file_path=file_path,
+                line_start=line,
+                line_end=line,
+                column_start=column,
+                fixable=False,
+                metadata={
+                    "severity_raw": severity_str,
+                },
+            )
+        except Exception as e:
+            LOGGER.warning(f"Failed to parse tsc error: {e}")
+            return None
+
+    def _generate_issue_id(
+        self,
+        code: str,
+        file: str,
+        line: int,
+        column: int,
+        message: str,
+    ) -> str:
+        """Generate deterministic issue ID.
+
+        Args:
+            code: TypeScript error code (e.g., TS1234).
+            file: File path.
+            line: Line number.
+            column: Column number.
+            message: Error message.
+
+        Returns:
+            Unique issue ID.
+        """
+        content = f"{code}:{file}:{line}:{column}:{message}"
+        hash_val = hashlib.sha256(content.encode()).hexdigest()[:12]
+        return f"ts-{code}-{hash_val}"