codeoptix 0.1.0__py3-none-any.whl

codeoptix/linters/bandit_linter.py

@@ -0,0 +1,172 @@
+"""Bandit security linter integration."""
+
+import json
+import subprocess
+from pathlib import Path
+
+from codeoptix.linters.base import BaseLinter, LinterIssue, LinterResult, Severity
+
+
+class BanditLinter(BaseLinter):
+    """Bandit security linter."""
+
+    def __init__(self, config: dict | None = None):
+        """Initialize Bandit linter."""
+        super().__init__(config)
+        self.name = "bandit"
+        self.severity_map = {
+            "HIGH": Severity.HIGH,
+            "MEDIUM": Severity.MEDIUM,
+            "LOW": Severity.LOW,
+        }
+
+    def is_available(self) -> bool:
+        """Check if bandit is available."""
+        try:
+            subprocess.run(
+                ["bandit", "--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 bandit on code."""
+        import time
+
+        start_time = time.time()
+
+        if not self.is_available():
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=[],
+                errors=["Bandit not found in PATH. Install with: pip install bandit"],
+                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 = ["bandit", "-f", "json", "-q", "-r"]
+
+        # Add specific files if provided
+        if files:
+            cmd.extend(files)
+        else:
+            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=["Bandit execution timed out"],
+                execution_time=60.0,
+            )
+        except Exception as e:
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=[],
+                errors=[f"Bandit error: {e!s}"],
+                execution_time=time.time() - start_time,
+            )
+
+    def parse_output(
+        self,
+        output: str,
+        stderr: str,
+        returncode: int,
+        execution_time: float,
+    ) -> LinterResult:
+        """Parse bandit JSON output."""
+        issues = []
+        errors = []
+
+        if stderr:
+            errors.append(stderr)
+
+        try:
+            data = json.loads(output)
+
+            # Bandit returns results in "results" key
+            for item in data.get("results", []):
+                severity = self.severity_map.get(
+                    item.get("issue_severity", "LOW"),
+                    Severity.LOW,
+                )
+
+                # Bandit severity mapping
+                if item.get("issue_confidence", "LOW") == "HIGH" and severity == Severity.LOW:
+                    severity = Severity.MEDIUM
+
+                issue = LinterIssue(
+                    linter=self.name,
+                    severity=severity,
+                    message=item.get("issue_text", "Unknown issue"),
+                    file=item.get("filename", ""),
+                    line=item.get("line_number"),
+                    code=item.get("code"),
+                    rule_id=item.get("test_id"),
+                    confidence=self._parse_confidence(item.get("issue_confidence")),
+                )
+                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 bandit JSON output")
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=issues,
+                errors=errors,
+                execution_time=execution_time,
+                raw_output=output,
+            )
+
+    def _parse_confidence(self, confidence: str | None) -> float | None:
+        """Parse confidence string to float."""
+        if not confidence:
+            return None
+
+        confidence_map = {
+            "HIGH": 0.9,
+            "MEDIUM": 0.6,
+            "LOW": 0.3,
+        }
+        return confidence_map.get(confidence.upper(), 0.5)

codeoptix/linters/base.py

@@ -0,0 +1,105 @@
+"""Base classes for linter integration."""
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+
+class Severity(str, Enum):
+    """Issue severity levels."""
+
+    CRITICAL = "critical"
+    HIGH = "high"
+    MEDIUM = "medium"
+    LOW = "low"
+    INFO = "info"
+
+
+@dataclass
+class LinterIssue:
+    """Represents a single linter issue."""
+
+    linter: str
+    severity: Severity
+    message: str
+    file: str
+    line: int | None = None
+    column: int | None = None
+    code: str | None = None
+    rule_id: str | None = None
+    confidence: float | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "linter": self.linter,
+            "severity": self.severity.value,
+            "message": self.message,
+            "file": self.file,
+            "line": self.line,
+            "column": self.column,
+            "code": self.code,
+            "rule_id": self.rule_id,
+            "confidence": self.confidence,
+        }
+
+
+@dataclass
+class LinterResult:
+    """Result from running a linter."""
+
+    linter: str
+    success: bool
+    issues: list[LinterIssue]
+    errors: list[str]
+    execution_time: float
+    raw_output: str | None = None
+
+    @property
+    def issue_count(self) -> int:
+        """Get total issue count."""
+        return len(self.issues)
+
+    @property
+    def critical_count(self) -> int:
+        """Get critical issue count."""
+        return sum(1 for issue in self.issues if issue.severity == Severity.CRITICAL)
+
+    @property
+    def high_count(self) -> int:
+        """Get high severity issue count."""
+        return sum(1 for issue in self.issues if issue.severity == Severity.HIGH)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "linter": self.linter,
+            "success": self.success,
+            "issue_count": self.issue_count,
+            "critical_count": self.critical_count,
+            "high_count": self.high_count,
+            "issues": [issue.to_dict() for issue in self.issues],
+            "errors": self.errors,
+            "execution_time": self.execution_time,
+        }
+
+
+class BaseLinter:
+    """Base class for linter implementations."""
+
+    def __init__(self, config: dict[str, Any] | None = None):
+        """Initialize linter."""
+        self.config = config or {}
+        self.name = self.__class__.__name__.replace("Linter", "").lower()
+
+    def is_available(self) -> bool:
+        """Check if linter is available in PATH."""
+        raise NotImplementedError
+
+    def run(self, path: str, files: list[str] | None = None) -> LinterResult:
+        """Run linter on code."""
+        raise NotImplementedError
+
+    def parse_output(self, output: str, stderr: str, returncode: int) -> LinterResult:
+        """Parse linter output."""
+        raise NotImplementedError

codeoptix/linters/coverage_linter.py

@@ -0,0 +1,156 @@
+"""coverage.py test coverage linter integration."""
+
+import subprocess
+from pathlib import Path
+
+from codeoptix.linters.base import BaseLinter, LinterIssue, LinterResult, Severity
+
+
+class CoverageLinter(BaseLinter):
+    """coverage.py test coverage analyzer."""
+
+    def __init__(self, config: dict | None = None):
+        """Initialize coverage linter."""
+        super().__init__(config)
+        self.name = "coverage"
+        self.min_coverage = self.config.get("min_coverage", 80.0)
+
+    def is_available(self) -> bool:
+        """Check if coverage is available."""
+        try:
+            subprocess.run(
+                ["coverage", "--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 coverage analysis."""
+        import time
+
+        start_time = time.time()
+
+        if not self.is_available():
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=[],
+                errors=["coverage not found in PATH. Install with: pip install coverage"],
+                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,
+            )
+
+        # Coverage needs to be run after tests
+        # We'll check for existing coverage data or report
+        coverage_data_file = path_obj / ".coverage"
+        coverage_xml = path_obj / "coverage.xml"
+        path_obj / "htmlcov"
+
+        # Check if coverage data exists
+        if not coverage_data_file.exists() and not coverage_xml.exists():
+            return LinterResult(
+                linter=self.name,
+                success=True,
+                issues=[],
+                errors=["No coverage data found. Run tests with coverage first: pytest --cov"],
+                execution_time=0.0,
+            )
+
+        try:
+            # Generate report
+            cmd = ["coverage", "report", "--format=total"]
+
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                cwd=str(path_obj) if path_obj.is_dir() else str(path_obj.parent),
+                timeout=30,
+                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=["Coverage execution timed out"],
+                execution_time=30.0,
+            )
+        except Exception as e:
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=[],
+                errors=[f"Coverage error: {e!s}"],
+                execution_time=time.time() - start_time,
+            )
+
+    def parse_output(
+        self,
+        output: str,
+        stderr: str,
+        returncode: int,
+        execution_time: float,
+    ) -> LinterResult:
+        """Parse coverage output."""
+        import re
+
+        issues = []
+        errors = []
+
+        if stderr:
+            errors.append(stderr)
+
+        # Parse coverage percentage
+        # Coverage format: "TOTAL    XXX    XX%"
+        pattern = r"TOTAL\s+\d+\s+(\d+)%"
+        match = re.search(pattern, output)
+
+        if match:
+            coverage_percent = float(match.group(1))
+
+            if coverage_percent < self.min_coverage:
+                severity = Severity.HIGH if coverage_percent < 50 else Severity.MEDIUM
+
+                issue = LinterIssue(
+                    linter=self.name,
+                    severity=severity,
+                    message=f"Test coverage is {coverage_percent:.1f}%, below minimum {self.min_coverage}%",
+                    file="coverage",
+                    rule_id="COVERAGE-LOW",
+                )
+                issues.append(issue)
+        else:
+            # Try to parse from XML if available
+            # Or just report that coverage was checked
+            pass
+
+        return LinterResult(
+            linter=self.name,
+            success=returncode == 0 and len(issues) == 0,
+            issues=issues,
+            errors=errors,
+            execution_time=execution_time,
+            raw_output=output,
+        )

codeoptix/linters/flake8_linter.py

@@ -0,0 +1,156 @@
+"""Flake8 style guide linter integration."""
+
+import subprocess
+from pathlib import Path
+
+from codeoptix.linters.base import BaseLinter, LinterIssue, LinterResult, Severity
+
+
+class Flake8Linter(BaseLinter):
+    """Flake8 style guide linter."""
+
+    def __init__(self, config: dict | None = None):
+        """Initialize Flake8 linter."""
+        super().__init__(config)
+        self.name = "flake8"
+        self.severity_map = {
+            "E": Severity.HIGH,  # Error
+            "W": Severity.MEDIUM,  # Warning
+            "F": Severity.HIGH,  # Pyflakes
+            "C": Severity.LOW,  # McCabe complexity
+            "N": Severity.LOW,  # Naming
+            "B": Severity.MEDIUM,  # flake8-bugbear
+        }
+
+    def is_available(self) -> bool:
+        """Check if flake8 is available."""
+        try:
+            subprocess.run(
+                ["flake8", "--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 flake8 on code."""
+        import time
+
+        start_time = time.time()
+
+        if not self.is_available():
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=[],
+                errors=["Flake8 not found in PATH. Install with: pip install flake8"],
+                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 = ["flake8"]
+
+        # Add specific files if provided
+        if files:
+            cmd.extend(files)
+        elif path_obj.is_file() 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=["Flake8 execution timed out"],
+                execution_time=60.0,
+            )
+        except Exception as e:
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=[],
+                errors=[f"Flake8 error: {e!s}"],
+                execution_time=time.time() - start_time,
+            )
+
+    def parse_output(
+        self,
+        output: str,
+        stderr: str,
+        returncode: int,
+        execution_time: float,
+    ) -> LinterResult:
+        """Parse flake8 output."""
+        import re
+
+        issues = []
+        errors = []
+
+        if stderr:
+            errors.append(stderr)
+
+        # Flake8 format: filename:line:column: code message
+        pattern = r"(.+?):(\d+):(\d+):\s*([EWFNCB]\d+)\s+(.+?)$"
+
+        for line in output.split("\n"):
+            line = line.strip()
+            if not line:
+                continue
+
+            match = re.match(pattern, line)
+            if match:
+                file_path, line_num, col_num, code, message = match.groups()
+
+                # Determine severity from error code
+                error_type = code[0] if code else "W"
+                severity = self.severity_map.get(error_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,
+                    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,
+        )