codeoptix 0.1.0__py3-none-any.whl

codeoptix/linters/pip_audit_linter.py

@@ -0,0 +1,152 @@
+"""pip-audit package vulnerability linter integration."""
+
+import json
+import subprocess
+from pathlib import Path
+
+from codeoptix.linters.base import BaseLinter, LinterIssue, LinterResult, Severity
+
+
+class PipAuditLinter(BaseLinter):
+    """pip-audit package vulnerability scanner."""
+
+    def __init__(self, config: dict | None = None):
+        """Initialize pip-audit linter."""
+        super().__init__(config)
+        self.name = "pip-audit"
+
+    def is_available(self) -> bool:
+        """Check if pip-audit is available."""
+        try:
+            subprocess.run(
+                ["pip-audit", "--version"],
+                capture_output=True,
+                timeout=5,
+                check=False,
+            )
+            return True
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return False
+
+    def run(self, path: str, files: list[str] | None = None) -> LinterResult:
+        """Run pip-audit on packages."""
+        import time
+
+        start_time = time.time()
+
+        if not self.is_available():
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=[],
+                errors=["pip-audit not found in PATH. Install with: pip install pip-audit"],
+                execution_time=0.0,
+            )
+
+        try:
+            # Build command
+            cmd = ["pip-audit", "--format=json"]
+
+            # Check for requirements file
+            path_obj = Path(path)
+            if path_obj.is_file() and path_obj.name in ["requirements.txt", "requirements-dev.txt"]:
+                cmd.extend(["--requirement", str(path_obj)])
+            elif path_obj.is_dir():
+                req_file = path_obj / "requirements.txt"
+                if req_file.exists():
+                    cmd.extend(["--requirement", str(req_file)])
+
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=60,
+                check=False,
+            )
+
+            execution_time = time.time() - start_time
+            return self.parse_output(
+                result.stdout,
+                result.stderr,
+                result.returncode,
+                execution_time,
+            )
+        except subprocess.TimeoutExpired:
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=[],
+                errors=["pip-audit execution timed out"],
+                execution_time=60.0,
+            )
+        except Exception as e:
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=[],
+                errors=[f"pip-audit error: {e!s}"],
+                execution_time=time.time() - start_time,
+            )
+
+    def parse_output(
+        self,
+        output: str,
+        stderr: str,
+        returncode: int,
+        execution_time: float,
+    ) -> LinterResult:
+        """Parse pip-audit JSON output."""
+        issues = []
+        errors = []
+
+        if stderr:
+            errors.append(stderr)
+
+        try:
+            data = json.loads(output) if output.strip() else {}
+
+            # pip-audit JSON format: {"vulnerabilities": [...]}
+            vulnerabilities = data.get("vulnerabilities", [])
+
+            for vuln in vulnerabilities:
+                name = vuln.get("name", "unknown")
+                installed_version = vuln.get("installed_version", "")
+                vuln_id = vuln.get("id", "")
+                fix_versions = vuln.get("fix_versions", [])
+
+                # Determine severity
+                severity = Severity.HIGH
+                if "critical" in str(vuln).lower():
+                    severity = Severity.CRITICAL
+
+                message = f"{name} {installed_version}: {vuln_id}"
+                if fix_versions:
+                    message += f" [Fix: {', '.join(fix_versions)}]"
+
+                issue = LinterIssue(
+                    linter=self.name,
+                    severity=severity,
+                    message=message,
+                    file="requirements.txt",
+                    rule_id=vuln_id,
+                )
+                issues.append(issue)
+
+            return LinterResult(
+                linter=self.name,
+                success=returncode == 0 or len(issues) == 0,
+                issues=issues,
+                errors=errors,
+                execution_time=execution_time,
+                raw_output=output,
+            )
+        except json.JSONDecodeError:
+            errors.append("Failed to parse pip-audit JSON output")
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=issues,
+                errors=errors,
+                execution_time=execution_time,
+                raw_output=output,
+            )

codeoptix/linters/pylint_linter.py

@@ -0,0 +1,198 @@
+"""Pylint code quality linter integration."""
+
+import json
+import re
+import subprocess
+from pathlib import Path
+
+from codeoptix.linters.base import BaseLinter, LinterIssue, LinterResult, Severity
+
+
+class PylintLinter(BaseLinter):
+    """Pylint code quality linter."""
+
+    def __init__(self, config: dict | None = None):
+        """Initialize Pylint linter."""
+        super().__init__(config)
+        self.name = "pylint"
+        self.severity_map = {
+            "E": Severity.HIGH,  # Error
+            "W": Severity.MEDIUM,  # Warning
+            "C": Severity.LOW,  # Convention
+            "R": Severity.LOW,  # Refactor
+            "F": Severity.CRITICAL,  # Fatal
+        }
+
+    def is_available(self) -> bool:
+        """Check if pylint is available."""
+        try:
+            subprocess.run(
+                ["pylint", "--version"],
+                capture_output=True,
+                timeout=5,
+                check=False,
+            )
+            return True
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return False
+
+    def run(self, path: str, files: list[str] | None = None) -> LinterResult:
+        """Run pylint on code."""
+        import time
+
+        start_time = time.time()
+
+        if not self.is_available():
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=[],
+                errors=["Pylint not found in PATH. Install with: pip install pylint"],
+                execution_time=0.0,
+            )
+
+        path_obj = Path(path)
+        if not path_obj.exists():
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=[],
+                errors=[f"Path not found: {path}"],
+                execution_time=0.0,
+            )
+
+        # Build command
+        cmd = [
+            "pylint",
+            "--output-format=json",
+            "--disable=all",
+            "--enable=E,F,W,C,R",  # Enable all message types
+        ]
+
+        # Add specific files if provided
+        if files:
+            cmd.extend(files)
+        # Find Python files
+        elif (path_obj.is_file() and path_obj.suffix == ".py") or path_obj.is_dir():
+            cmd.append(str(path_obj))
+
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=120,
+                check=False,
+            )
+
+            execution_time = time.time() - start_time
+            return self.parse_output(
+                result.stdout,
+                result.stderr,
+                result.returncode,
+                execution_time,
+            )
+        except subprocess.TimeoutExpired:
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=[],
+                errors=["Pylint execution timed out"],
+                execution_time=120.0,
+            )
+        except Exception as e:
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=[],
+                errors=[f"Pylint error: {e!s}"],
+                execution_time=time.time() - start_time,
+            )
+
+    def parse_output(
+        self,
+        output: str,
+        stderr: str,
+        returncode: int,
+        execution_time: float,
+    ) -> LinterResult:
+        """Parse pylint JSON output."""
+        issues = []
+        errors = []
+
+        if stderr:
+            errors.append(stderr)
+
+        try:
+            data = json.loads(output)
+
+            for item in data:
+                message_type = item.get("type", "W")
+                severity = self.severity_map.get(message_type, Severity.MEDIUM)
+
+                issue = LinterIssue(
+                    linter=self.name,
+                    severity=severity,
+                    message=item.get("message", "Unknown issue"),
+                    file=item.get("path", ""),
+                    line=item.get("line"),
+                    column=item.get("column"),
+                    code=item.get("symbol"),
+                    rule_id=item.get("message-id"),
+                )
+                issues.append(issue)
+
+            return LinterResult(
+                linter=self.name,
+                success=returncode == 0 or len(issues) == 0,
+                issues=issues,
+                errors=errors,
+                execution_time=execution_time,
+                raw_output=output,
+            )
+        except json.JSONDecodeError:
+            # Try parsing text output as fallback
+            return self._parse_text_output(output, stderr, returncode, execution_time)
+
+    def _parse_text_output(
+        self,
+        output: str,
+        stderr: str,
+        returncode: int,
+        execution_time: float,
+    ) -> LinterResult:
+        """Parse pylint text output as fallback."""
+        issues = []
+        errors = []
+
+        if stderr:
+            errors.append(stderr)
+
+        # Pylint text format: filename:line:column: message-type: message (message-id)
+        pattern = r"(.+?):(\d+):(\d+):\s*([EWCRF]):\s*(.+?)\s*\((.+?)\)"
+
+        for line in output.split("\n"):
+            match = re.match(pattern, line)
+            if match:
+                file_path, line_num, col_num, msg_type, message, rule_id = match.groups()
+                severity = self.severity_map.get(msg_type, Severity.MEDIUM)
+
+                issue = LinterIssue(
+                    linter=self.name,
+                    severity=severity,
+                    message=message.strip(),
+                    file=file_path,
+                    line=int(line_num) if line_num.isdigit() else None,
+                    column=int(col_num) if col_num.isdigit() else None,
+                    rule_id=rule_id,
+                )
+                issues.append(issue)
+
+        return LinterResult(
+            linter=self.name,
+            success=returncode == 0 or len(issues) == 0,
+            issues=issues,
+            errors=errors,
+            execution_time=execution_time,
+            raw_output=output,
+        )

codeoptix/linters/ruff_linter.py

@@ -0,0 +1,206 @@
+"""Ruff linter integration - extremely fast Python linter."""
+
+import json
+import subprocess
+from pathlib import Path
+
+from codeoptix.linters.base import BaseLinter, LinterIssue, LinterResult, Severity
+
+
+class RuffLinter(BaseLinter):
+    """Ruff linter - extremely fast Python linter written in Rust."""
+
+    def __init__(self, config: dict | None = None):
+        """Initialize Ruff linter."""
+        super().__init__(config)
+        self.name = "ruff"
+        self.severity_map = {
+            "E": Severity.HIGH,  # Error
+            "W": Severity.MEDIUM,  # Warning
+            "F": Severity.HIGH,  # Pyflakes
+            "I": Severity.LOW,  # isort
+            "N": Severity.LOW,  # pep8-naming
+            "UP": Severity.LOW,  # pyupgrade
+            "B": Severity.MEDIUM,  # flake8-bugbear
+            "C4": Severity.LOW,  # flake8-comprehensions
+            "SIM": Severity.LOW,  # flake8-simplify
+        }
+
+    def is_available(self) -> bool:
+        """Check if ruff is available."""
+        try:
+            subprocess.run(
+                ["ruff", "--version"],
+                capture_output=True,
+                timeout=5,
+                check=False,
+            )
+            return True
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return False
+
+    def _find_config_file(self, path: str) -> Path | None:
+        """Find ruff configuration file (ruff.toml, pyproject.toml, .ruff.toml)."""
+        path_obj = Path(path)
+
+        # Check common config locations
+        config_files = [
+            "ruff.toml",
+            ".ruff.toml",
+            "pyproject.toml",
+        ]
+
+        # Start from path and walk up
+        current = path_obj if path_obj.is_file() else path_obj.parent
+        while current != current.parent:
+            for config_file in config_files:
+                config_path = current / config_file
+                if config_path.exists():
+                    return config_path
+            current = current.parent
+
+        return None
+
+    def run(self, path: str, files: list[str] | None = None) -> LinterResult:
+        """Run ruff on code."""
+        import time
+
+        start_time = time.time()
+
+        if not self.is_available():
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=[],
+                errors=[
+                    "Ruff not found in PATH. Install with: pip install ruff or uv tool install ruff"
+                ],
+                execution_time=0.0,
+            )
+
+        path_obj = Path(path)
+        if not path_obj.exists():
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=[],
+                errors=[f"Path not found: {path}"],
+                execution_time=0.0,
+            )
+
+        # Find config file (use existing project config)
+        config_file = self._find_config_file(path)
+
+        # Build command
+        cmd = ["ruff", "check", "--output-format=json"]
+
+        # Use existing config if found
+        if config_file:
+            # Ruff automatically uses pyproject.toml or ruff.toml in project root
+            pass
+
+        # Add specific files if provided
+        if files:
+            cmd.extend(files)
+        elif (path_obj.is_file() and path_obj.suffix == ".py") or path_obj.is_dir():
+            cmd.append(str(path_obj))
+
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=60,
+                check=False,
+            )
+
+            execution_time = time.time() - start_time
+            return self.parse_output(
+                result.stdout,
+                result.stderr,
+                result.returncode,
+                execution_time,
+            )
+        except subprocess.TimeoutExpired:
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=[],
+                errors=["Ruff execution timed out"],
+                execution_time=60.0,
+            )
+        except Exception as e:
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=[],
+                errors=[f"Ruff error: {e!s}"],
+                execution_time=time.time() - start_time,
+            )
+
+    def parse_output(
+        self,
+        output: str,
+        stderr: str,
+        returncode: int,
+        execution_time: float,
+    ) -> LinterResult:
+        """Parse ruff JSON output."""
+        issues = []
+        errors = []
+
+        if stderr:
+            errors.append(stderr)
+
+        try:
+            # Ruff JSON output is a list of diagnostic objects
+            data = json.loads(output) if output.strip() else []
+
+            for item in data:
+                code = item.get("code", "")
+                severity_str = item.get("severity", "warning")
+
+                # Map ruff severity to our severity
+                if severity_str == "error":
+                    severity = Severity.HIGH
+                elif severity_str == "warning":
+                    severity = Severity.MEDIUM
+                else:
+                    severity = Severity.LOW
+
+                # Determine severity from code prefix if available
+                if code:
+                    code_prefix = code.split(".")[0] if "." in code else code
+                    if code_prefix in self.severity_map:
+                        severity = self.severity_map[code_prefix]
+
+                issue = LinterIssue(
+                    linter=self.name,
+                    severity=severity,
+                    message=item.get("message", "Unknown issue"),
+                    file=item.get("filename", ""),
+                    line=item.get("location", {}).get("row"),
+                    column=item.get("location", {}).get("column"),
+                    code=code,
+                    rule_id=code,
+                )
+                issues.append(issue)
+
+            return LinterResult(
+                linter=self.name,
+                success=returncode == 0 or len(issues) == 0,
+                issues=issues,
+                errors=errors,
+                execution_time=execution_time,
+                raw_output=output,
+            )
+        except json.JSONDecodeError:
+            errors.append("Failed to parse ruff JSON output")
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=issues,
+                errors=errors,
+                execution_time=execution_time,
+                raw_output=output,
+            )