codeoptix 0.1.3__py3-none-any.whl

codeoptix/linters/html_accessibility_linter.py

@@ -0,0 +1,374 @@
+"""Custom HTML accessibility analyzer - no external dependencies."""
+
+from html.parser import HTMLParser
+from pathlib import Path
+
+from codeoptix.linters.base import BaseLinter, LinterIssue, LinterResult, Severity
+
+
+class HTMLAccessibilityParser(HTMLParser):
+    """HTML parser for accessibility analysis."""
+
+    def __init__(self):
+        """Initialize parser."""
+        super().__init__()
+        self.issues = []
+        self.current_tag: str | None = None
+        self.current_attrs: dict[str, str] = {}
+        self.has_main = False
+        self.has_nav = False
+        self.images_without_alt: list[tuple[int, int]] = []
+        self.headings_order: list[tuple[tuple[int, int], int, int]] = []
+        self.last_heading_level = 0
+        self.html_lang: str | None = None
+        self.heading_tags_seen: list[tuple[str, tuple[int, int]]] = []
+        self.links_missing_text: list[tuple[int, int, dict[str, str]]] = []
+        self.buttons_missing_text: list[tuple[int, int, dict[str, str]]] = []
+        self.inputs_missing_label: list[tuple[int, int, dict[str, str]]] = []
+        self.labels_by_for: dict[str, tuple[int, int]] = {}
+        self.current_data_buffer: list[str] = []
+        self.focus_outline_suppressed = False
+        self.suspicious_tabindex: list[tuple[int, int, dict[str, str]]] = []
+        self.aria_role_issues: list[tuple[int, int, str, str]] = []
+
+    def handle_starttag(self, tag, attrs):
+        """Handle start tag."""
+        self.current_tag = tag
+        self.current_attrs = {k: v for (k, v) in attrs}
+        self.current_data_buffer = []
+
+        # Document root and language
+        if tag == "html":
+            lang = self.current_attrs.get("lang") or self.current_attrs.get("xml:lang")
+            if lang:
+                self.html_lang = lang.strip()
+
+        # Semantic HTML landmarks
+        if tag == "main":
+            self.has_main = True
+        elif tag == "nav":
+            self.has_nav = True
+
+        # Check images
+        if tag == "img":
+            alt = self.current_attrs.get("alt")
+            if alt is None or alt.strip() == "":
+                self.images_without_alt.append(self.getpos())
+
+        # Headings and order
+        if tag in ["h1", "h2", "h3", "h4", "h5", "h6"]:
+            level = int(tag[1])
+            self.heading_tags_seen.append((tag, self.getpos()))
+            if self.last_heading_level and level > self.last_heading_level + 1:
+                self.headings_order.append((self.getpos(), level, self.last_heading_level))
+            self.last_heading_level = level
+
+        # Labels
+        if tag == "label":
+            label_for = self.current_attrs.get("for")
+            if label_for:
+                self.labels_by_for[label_for] = self.getpos()
+
+        # Inputs that should have labels
+        if tag == "input" and self.current_attrs.get("type") not in [
+            "hidden",
+            "submit",
+            "button",
+            "image",
+        ]:
+            input_id = self.current_attrs.get("id")
+            if not input_id or input_id not in self.labels_by_for:
+                # We will also check aria-label/labelledby via attributes
+                self.inputs_missing_label.append(
+                    (self.getpos()[0], self.getpos()[1], dict(self.current_attrs))
+                )
+
+        # Links and buttons: record for later text/aria checks
+        if tag == "a":
+            href = self.current_attrs.get("href")
+            if href:
+                # Will decide missing text after data collected
+                self.links_missing_text.append(
+                    (self.getpos()[0], self.getpos()[1], dict(self.current_attrs))
+                )
+
+        if tag == "button":
+            self.buttons_missing_text.append(
+                (self.getpos()[0], self.getpos()[1], dict(self.current_attrs))
+            )
+
+        # Tabindex heuristics
+        tabindex = self.current_attrs.get("tabindex")
+        if tabindex is not None:
+            try:
+                tabindex_val = int(tabindex)
+                if tabindex_val > 0 or tabindex_val < -1:
+                    self.suspicious_tabindex.append(
+                        (self.getpos()[0], self.getpos()[1], dict(self.current_attrs))
+                    )
+            except ValueError:
+                self.suspicious_tabindex.append(
+                    (self.getpos()[0], self.getpos()[1], dict(self.current_attrs))
+                )
+
+        # Simple ARIA/role checks
+        role = self.current_attrs.get("role")
+        if role:
+            # Example: role="button" on non-interactive element
+            if role == "button" and tag not in ("button", "a", "input"):
+                self.aria_role_issues.append((self.getpos()[0], self.getpos()[1], tag, role))
+
+    def handle_data(self, data):
+        """Handle text data."""
+        if self.current_tag:
+            self.current_data_buffer.append(data)
+
+    def handle_endtag(self, tag):
+        """Handle end tag, used to decide on text content for links/buttons."""
+        # Consolidate buffered text
+        text_content = "".join(self.current_data_buffer or []).strip()
+
+        if tag == "a":
+            if self.links_missing_text:
+                _line, _col, attrs = self.links_missing_text[-1]
+                # Only flag as missing if no text AND no aria-label
+                if not text_content and not attrs.get("aria-label"):
+                    # Keep as-is; will be converted to issues later
+                    pass
+                else:
+                    # Remove last entry if it actually had content
+                    self.links_missing_text.pop()
+
+        if tag == "button":
+            if self.buttons_missing_text:
+                _line, _col, attrs = self.buttons_missing_text[-1]
+                if text_content or attrs.get("aria-label"):
+                    # Button has accessible name; drop from missing list
+                    self.buttons_missing_text.pop()
+
+        self.current_tag = None
+        self.current_attrs = {}
+        self.current_data_buffer = []
+
+
+class HTMLAccessibilityLinter(BaseLinter):
+    """Custom HTML accessibility analyzer - no external dependencies."""
+
+    def __init__(self, config: dict | None = None):
+        """Initialize HTML accessibility linter."""
+        super().__init__(config)
+        self.name = "html-accessibility"
+
+    def is_available(self) -> bool:
+        """Always available - pure Python, no dependencies."""
+        return True
+
+    def run(self, path: str, files: list[str] | None = None) -> LinterResult:
+        """Run HTML accessibility analysis."""
+        import time
+
+        start_time = time.time()
+
+        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 HTML files
+        html_files = []
+        if path_obj.is_file() and path_obj.suffix in [".html", ".htm"]:
+            html_files = [path_obj]
+        elif path_obj.is_dir():
+            if files:
+                html_files = [Path(f) for f in files if Path(f).suffix in [".html", ".htm"]]
+            else:
+                html_files = list(path_obj.rglob("*.html")) + list(path_obj.rglob("*.htm"))
+
+        if not html_files:
+            return LinterResult(
+                linter=self.name,
+                success=True,
+                issues=[],
+                errors=["No HTML files found"],
+                execution_time=0.0,
+            )
+
+        all_issues = []
+
+        for html_file in html_files:
+            try:
+                with open(html_file, encoding="utf-8") as f:
+                    html_content = f.read()
+
+                # Parse HTML
+                parser = HTMLAccessibilityParser()
+                parser.feed(html_content)
+
+                # Generate issues
+                file_issues = self._generate_issues(html_file, parser)
+                all_issues.extend(file_issues)
+
+            except Exception as e:
+                all_issues.append(
+                    LinterIssue(
+                        linter=self.name,
+                        severity=Severity.MEDIUM,
+                        message=f"Failed to parse HTML: {e!s}",
+                        file=str(html_file),
+                    )
+                )
+
+        execution_time = time.time() - start_time
+
+        return LinterResult(
+            linter=self.name,
+            success=len(all_issues) == 0,
+            issues=all_issues,
+            errors=[],
+            execution_time=execution_time,
+        )
+
+    def _generate_issues(
+        self, html_file: Path, parser: HTMLAccessibilityParser
+    ) -> list[LinterIssue]:
+        """Generate accessibility issues from parser results."""
+        issues = []
+
+        # Language of page (WCAG 3.1.1)
+        if parser.html_lang is None:
+            issues.append(
+                LinterIssue(
+                    linter=self.name,
+                    severity=Severity.MEDIUM,
+                    message="Missing lang attribute on <html> element",
+                    file=str(html_file),
+                    rule_id="A11Y-MISSING-LANG",
+                )
+            )
+
+        # Semantic HTML landmarks (WCAG 1.3.1 / 2.4.1)
+        if not parser.has_main:
+            issues.append(
+                LinterIssue(
+                    linter=self.name,
+                    severity=Severity.MEDIUM,
+                    message="Missing <main> element for main content",
+                    file=str(html_file),
+                    rule_id="A11Y-MISSING-MAIN",
+                )
+            )
+
+        # Check images without alt text
+        for pos in parser.images_without_alt:
+            issues.append(
+                LinterIssue(
+                    linter=self.name,
+                    severity=Severity.HIGH,
+                    message="Image missing alt text or empty alt text",
+                    file=str(html_file),
+                    line=pos[0],
+                    rule_id="A11Y-MISSING-ALT",
+                )
+            )
+
+        # Check heading order (WCAG 1.3.1)
+        for pos, level, last_level in parser.headings_order:
+            issues.append(
+                LinterIssue(
+                    linter=self.name,
+                    severity=Severity.MEDIUM,
+                    message=f"Heading level {level} skipped (previous was {last_level})",
+                    file=str(html_file),
+                    line=pos[0],
+                    rule_id="A11Y-HEADING-ORDER",
+                )
+            )
+
+        # Basic heading presence (at least one h1)
+        has_h1 = any(tag == "h1" for tag, _pos in parser.heading_tags_seen)
+        if not has_h1:
+            issues.append(
+                LinterIssue(
+                    linter=self.name,
+                    severity=Severity.MEDIUM,
+                    message="Missing top-level <h1> heading",
+                    file=str(html_file),
+                    rule_id="A11Y-MISSING-H1",
+                )
+            )
+
+        # Links without accessible name (WCAG 2.4.4 / 4.1.2)
+        for line, _col, attrs in parser.links_missing_text:
+            issues.append(
+                LinterIssue(
+                    linter=self.name,
+                    severity=Severity.MEDIUM,
+                    message="Link has no accessible name (no text or aria-label)",
+                    file=str(html_file),
+                    line=line,
+                    rule_id="A11Y-LINK-NO-NAME",
+                )
+            )
+
+        # Buttons without accessible name (WCAG 4.1.2)
+        for line, _col, attrs in parser.buttons_missing_text:
+            issues.append(
+                LinterIssue(
+                    linter=self.name,
+                    severity=Severity.MEDIUM,
+                    message="Button has no accessible name (no text or aria-label)",
+                    file=str(html_file),
+                    line=line,
+                    rule_id="A11Y-BUTTON-NO-NAME",
+                )
+            )
+
+        # Inputs without labels (WCAG 1.3.1 / 3.3.2)
+        for line, _col, attrs in parser.inputs_missing_label:
+            # If aria-label or aria-labelledby exists, treat as labeled
+            if attrs.get("aria-label") or attrs.get("aria-labelledby"):
+                continue
+            issues.append(
+                LinterIssue(
+                    linter=self.name,
+                    severity=Severity.MEDIUM,
+                    message="Form control has no associated label or aria-label",
+                    file=str(html_file),
+                    line=line,
+                    rule_id="A11Y-FORM-NO-LABEL",
+                )
+            )
+
+        # Tabindex misuse (WCAG 2.1.1 / 2.4.3)
+        for line, _col, attrs in parser.suspicious_tabindex:
+            tabindex_val = attrs.get("tabindex")
+            issues.append(
+                LinterIssue(
+                    linter=self.name,
+                    severity=Severity.LOW,
+                    message=f"Suspicious tabindex value '{tabindex_val}' (consider 0 or -1)",
+                    file=str(html_file),
+                    line=line,
+                    rule_id="A11Y-TABINDEX-SUSPICIOUS",
+                )
+            )
+
+        # Simple ARIA role issues
+        for line, _col, tag, role in parser.aria_role_issues:
+            issues.append(
+                LinterIssue(
+                    linter=self.name,
+                    severity=Severity.LOW,
+                    message=f"Suspicious ARIA role usage: role='{role}' on <{tag}>",
+                    file=str(html_file),
+                    line=line,
+                    rule_id="A11Y-ARIA-ROLE-MISMATCH",
+                )
+            )
+
+        return issues

codeoptix/linters/language_detector.py

@@ -0,0 +1,150 @@
+"""Language detection for automatic linter selection."""
+
+from pathlib import Path
+
+
+class LanguageDetector:
+    """Detects programming languages from file paths."""
+
+    # Language to file extension mapping
+    LANGUAGE_EXTENSIONS: dict[str, set[str]] = {
+        "python": {".py", ".pyi", ".pyw"},
+        "javascript": {".js", ".jsx", ".mjs", ".cjs"},
+        "typescript": {".ts", ".tsx"},
+        "java": {".java"},
+        "go": {".go"},
+        "rust": {".rs"},
+        "cpp": {".cpp", ".cc", ".cxx", ".hpp", ".h", ".hxx"},
+        "c": {".c", ".h"},
+        "ruby": {".rb"},
+        "php": {".php"},
+        "swift": {".swift"},
+        "kotlin": {".kt", ".kts"},
+        "scala": {".scala"},
+        "dart": {".dart"},
+        "r": {".r", ".R"},
+        "shell": {".sh", ".bash", ".zsh", ".fish"},
+    }
+
+    # Language to linter mapping (zero new dependencies)
+    LANGUAGE_LINTERS: dict[str, list[str]] = {
+        "python": ["ruff", "bandit", "pylint", "flake8", "mypy", "safety", "pip-audit", "coverage"],
+        "html": ["html-accessibility"],  # Custom tool, no dependency
+        "javascript": [],  # No JS linters yet (would require Node.js)
+        "typescript": [],  # No TS linters yet
+        "java": [],  # No Java linters yet
+        "go": [],  # No Go linters yet
+        "rust": [],  # No Rust linters yet
+    }
+
+    @classmethod
+    def detect_language(cls, file_path: str) -> str | None:
+        """
+        Detect language from file path.
+
+        Args:
+            file_path: Path to file
+
+        Returns:
+            Language name or None
+        """
+        path = Path(file_path)
+        extension = path.suffix.lower()
+
+        for language, extensions in cls.LANGUAGE_EXTENSIONS.items():
+            if extension in extensions:
+                return language
+
+        return None
+
+    @classmethod
+    def detect_languages(cls, file_paths: list[str]) -> set[str]:
+        """
+        Detect languages from multiple file paths.
+
+        Args:
+            file_paths: List of file paths
+
+        Returns:
+            Set of detected languages
+        """
+        languages = set()
+        for file_path in file_paths:
+            language = cls.detect_language(file_path)
+            if language:
+                languages.add(language)
+        return languages
+
+    @classmethod
+    def get_linters_for_language(cls, language: str) -> list[str]:
+        """
+        Get recommended linters for a language.
+
+        Args:
+            language: Language name
+
+        Returns:
+            List of linter names
+        """
+        return cls.LANGUAGE_LINTERS.get(language.lower(), [])
+
+    @classmethod
+    def get_linters_for_files(cls, file_paths: list[str]) -> list[str]:
+        """
+        Get recommended linters for files.
+
+        Args:
+            file_paths: List of file paths
+
+        Returns:
+            List of linter names
+        """
+        languages = cls.detect_languages(file_paths)
+        linters = set()
+
+        for language in languages:
+            linters.update(cls.get_linters_for_language(language))
+
+        return list(linters)
+
+    @classmethod
+    def find_config_files(cls, path: str) -> dict[str, Path]:
+        """
+        Find existing linter configuration files.
+
+        Args:
+            path: Path to search
+
+        Returns:
+            Dictionary mapping linter names to config file paths
+        """
+        path_obj = Path(path)
+        if path_obj.is_file():
+            search_dir = path_obj.parent
+        else:
+            search_dir = path_obj
+
+        config_files = {}
+
+        # Common config file patterns
+        config_patterns = {
+            "ruff": ["ruff.toml", ".ruff.toml", "pyproject.toml"],
+            "pylint": [".pylintrc", "pylintrc", "setup.cfg", "pyproject.toml"],
+            "flake8": [".flake8", "setup.cfg", "tox.ini", "pyproject.toml"],
+            "bandit": ["bandit.yaml", ".bandit", "setup.cfg", "pyproject.toml"],
+            "mypy": ["mypy.ini", ".mypy.ini", "setup.cfg", "pyproject.toml"],
+        }
+
+        # Walk up directory tree
+        current = search_dir
+        while current != current.parent:
+            for linter, patterns in config_patterns.items():
+                if linter not in config_files:
+                    for pattern in patterns:
+                        config_path = current / pattern
+                        if config_path.exists():
+                            config_files[linter] = config_path
+                            break
+            current = current.parent
+
+        return config_files

codeoptix/linters/mypy_linter.py

@@ -0,0 +1,184 @@
+"""mypy type checker linter integration."""
+
+import subprocess
+from pathlib import Path
+
+from codeoptix.linters.base import BaseLinter, LinterIssue, LinterResult, Severity
+
+
+class MypyLinter(BaseLinter):
+    """mypy static type checker."""
+
+    def __init__(self, config: dict | None = None):
+        """Initialize mypy linter."""
+        super().__init__(config)
+        self.name = "mypy"
+
+    def is_available(self) -> bool:
+        """Check if mypy is available."""
+        try:
+            subprocess.run(
+                ["mypy", "--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 mypy configuration file."""
+        path_obj = Path(path)
+
+        config_files = [
+            "mypy.ini",
+            ".mypy.ini",
+            "setup.cfg",
+            "pyproject.toml",
+        ]
+
+        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():
+                    # For pyproject.toml, check if it has [tool.mypy] section
+                    if config_file == "pyproject.toml":
+                        try:
+                            with open(config_path) as f:
+                                content = f.read()
+                                if "[tool.mypy]" in content:
+                                    return config_path
+                        except OSError:
+                            pass
+                    else:
+                        return config_path
+            current = current.parent
+
+        return None
+
+    def run(self, path: str, files: list[str] | None = None) -> LinterResult:
+        """Run mypy on code."""
+        import time
+
+        start_time = time.time()
+
+        if not self.is_available():
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=[],
+                errors=["mypy not found in PATH. Install with: pip install mypy"],
+                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 (mypy automatically uses it)
+        self._find_config_file(path)
+
+        # Build command
+        cmd = ["mypy", "--show-error-codes", "--no-error-summary"]
+
+        # 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=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=["mypy execution timed out"],
+                execution_time=120.0,
+            )
+        except Exception as e:
+            return LinterResult(
+                linter=self.name,
+                success=False,
+                issues=[],
+                errors=[f"mypy error: {e!s}"],
+                execution_time=time.time() - start_time,
+            )
+
+    def parse_output(
+        self,
+        output: str,
+        stderr: str,
+        returncode: int,
+        execution_time: float,
+    ) -> LinterResult:
+        """Parse mypy output."""
+        import re
+
+        issues = []
+        errors = []
+
+        if stderr:
+            errors.append(stderr)
+
+        # mypy format: filename:line: error: message [error-code]
+        pattern = r"(.+?):(\d+):\s*(error|note|warning):\s*(.+?)(?:\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, level, message, error_code = match.groups()
+
+                # Map mypy levels to severity
+                if level == "error":
+                    severity = Severity.HIGH
+                elif level == "warning":
+                    severity = Severity.MEDIUM
+                else:
+                    severity = Severity.LOW
+
+                issue = LinterIssue(
+                    linter=self.name,
+                    severity=severity,
+                    message=message.strip(),
+                    file=file_path,
+                    line=int(line_num) if line_num.isdigit() else None,
+                    rule_id=error_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,
+        )