thailint 0.12.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

src/linters/file_placement/linter.py

@@ -20,6 +20,10 @@ Interfaces: lint_path(file_path) -> list[Violation], check_file_allowed(file_pat
 Implementation: Composition pattern with helper classes for each responsibility
     (ConfigLoader, PathResolver, PatternMatcher, PatternValidator, RuleChecker,
     ViolationFactory)
+
+Suppressions:
+    - srp.violation: Rule class coordinates multiple helper classes for comprehensive
+        file placement validation. Method count reflects composition orchestration.
 """
 
 import json
@@ -72,21 +76,31 @@ class FilePlacementLinter:
 
         # Load and validate config
         if config_obj:
-            # Handle both wrapped and unwrapped config formats
-            # Wrapped: {"file-placement": {...}} or {"file_placement": {...}}
-            # Unwrapped: {"directories": {...}, "global_deny": [...], ...}
-            # Try both hyphenated and underscored keys for backward compatibility
-            self.config = config_obj.get(
-                "file-placement", config_obj.get("file_placement", config_obj)
-            )
+            self.config = self._unwrap_config(config_obj)
         elif config_file:
-            self.config = self._components.config_loader.load_config_file(config_file)
+            raw_config = self._components.config_loader.load_config_file(config_file)
+            self.config = self._unwrap_config(raw_config)
         else:
             self.config = {}
 
         # Validate regex patterns in config
         self._components.pattern_validator.validate_config(self.config)
 
+    def _unwrap_config(self, config: dict[str, Any]) -> dict[str, Any]:
+        """Unwrap file-placement config from wrapper if present.
+
+        Args:
+            config: Raw config dict (may be wrapped or unwrapped)
+
+        Returns:
+            Unwrapped file-placement config dict
+        """
+        # Handle both wrapped and unwrapped config formats
+        # Wrapped: {"file-placement": {...}} or {"file_placement": {...}}
+        # Unwrapped: {"directories": {...}, "global_deny": [...], ...}
+        # Try both hyphenated and underscored keys for backward compatibility
+        return config.get("file-placement", config.get("file_placement", config))
+
     def lint_path(self, file_path: Path) -> list[Violation]:
         """Lint a single file path.
 

src/linters/file_placement/pattern_matcher.py

@@ -18,6 +18,7 @@ Implementation: Uses re.search() for pattern matching with IGNORECASE flag
 """
 
 import re
+from collections.abc import Sequence
 from re import Pattern
 
 
@@ -42,24 +43,40 @@ class PatternMatcher:
         return self._compiled_patterns[pattern]
 
     def match_deny_patterns(
-        self, path_str: str, deny_patterns: list[dict[str, str]]
+        self, path_str: str, deny_patterns: Sequence[dict[str, str] | str]
     ) -> tuple[bool, str | None]:
         """Check if path matches any deny patterns.
 
         Args:
             path_str: File path to check
-            deny_patterns: List of deny pattern dicts with 'pattern' and 'reason'
+            deny_patterns: List of deny patterns (either dicts with 'pattern'/'reason'
+                or plain regex strings for backward compatibility)
 
         Returns:
             Tuple of (is_denied, reason)
         """
         for deny_item in deny_patterns:
-            compiled = self._get_compiled(deny_item["pattern"])
+            pattern, reason = self._extract_pattern_and_reason(deny_item)
+            compiled = self._get_compiled(pattern)
             if compiled.search(path_str):
-                reason = deny_item.get("reason", "File not allowed in this location")
                 return True, reason
         return False, None
 
+    def _extract_pattern_and_reason(self, deny_item: dict[str, str] | str) -> tuple[str, str]:
+        """Extract pattern and reason from a deny item.
+
+        Args:
+            deny_item: Either a dict with 'pattern' key or a plain string pattern
+
+        Returns:
+            Tuple of (pattern, reason)
+        """
+        if isinstance(deny_item, str):
+            return deny_item, "File not allowed in this location"
+        return deny_item["pattern"], deny_item.get(
+            "reason", deny_item.get("message", "File not allowed in this location")
+        )
+
     def match_allow_patterns(self, path_str: str, allow_patterns: list[str]) -> bool:
         """Check if path matches any allow patterns.
 

src/linters/file_placement/pattern_validator.py

@@ -21,6 +21,20 @@ import re
 from typing import Any
 
 
+def _extract_pattern(deny_item: dict[str, str] | str) -> str:
+    """Extract pattern from a deny item.
+
+    Args:
+        deny_item: Either a dict with 'pattern' key or a plain string pattern
+
+    Returns:
+        The pattern string
+    """
+    if isinstance(deny_item, str):
+        return deny_item
+    return deny_item.get("pattern", "")
+
+
 class PatternValidator:
     """Validates regex patterns in file placement configuration."""
 
@@ -32,15 +46,15 @@ class PatternValidator:
         """Validate all regex patterns in configuration.
 
         Args:
-            config: Full configuration dict
+            config: File placement configuration dict (already unwrapped)
 
         Raises:
             ValueError: If any regex pattern is invalid
         """
-        fp_config = config.get("file-placement", {})
-        self._validate_directory_patterns(fp_config)
-        self._validate_global_patterns(fp_config)
-        self._validate_global_deny_patterns(fp_config)
+        # Config is already unwrapped from file-placement key by FilePlacementLinter
+        self._validate_directory_patterns(config)
+        self._validate_global_patterns(config)
+        self._validate_global_deny_patterns(config)
 
     def _validate_pattern(self, pattern: str) -> None:
         """Validate a single regex pattern.
@@ -74,7 +88,7 @@ class PatternValidator:
         """
         if "deny" in rules:
             for deny_item in rules["deny"]:
-                pattern = deny_item.get("pattern", "")
+                pattern = _extract_pattern(deny_item)
                 self._validate_pattern(pattern)
 
     def _validate_directory_patterns(self, fp_config: dict[str, Any]) -> None:
@@ -106,5 +120,5 @@ class PatternValidator:
         """
         if "global_deny" in fp_config:
             for deny_item in fp_config["global_deny"]:
-                pattern = deny_item.get("pattern", "")
+                pattern = _extract_pattern(deny_item)
                 self._validate_pattern(pattern)

src/linters/file_placement/rule_checker.py

@@ -177,14 +177,14 @@ class RuleChecker:
         return [violation] if violation else []
 
     def _check_global_deny(
-        self, path_str: str, rel_path: Path, global_deny: list[dict[str, str]]
+        self, path_str: str, rel_path: Path, global_deny: list[dict[str, str] | str]
     ) -> list[Violation]:
         """Check file against global deny patterns.
 
         Args:
             path_str: Normalized path string
             rel_path: Relative path object
-            global_deny: Global deny patterns
+            global_deny: Global deny patterns (dicts with pattern/reason or plain strings)
 
         Returns:
             List of violations

src/linters/lazy_ignores/__init__.py

@@ -0,0 +1,43 @@
+"""
+Purpose: Lazy-ignores linter package exports
+
+Scope: Detect unjustified linting suppressions in code files
+
+Overview: Package providing lazy-ignores linter functionality. Detects when AI agents add
+    linting suppressions (noqa, type:ignore, pylint:disable, nosec, thailint:ignore, etc.)
+    or test skips (pytest.mark.skip, it.skip, describe.skip) without proper justification
+    in the file header's Suppressions section. Enforces header-based declaration model
+    where all suppressions must be documented with human approval.
+
+Dependencies: src.core for base types, re for pattern matching
+
+Exports: IgnoreType, IgnoreDirective, SuppressionEntry, LazyIgnoresConfig,
+    PythonIgnoreDetector, TypeScriptIgnoreDetector, TestSkipDetector, SuppressionsParser
+
+Interfaces: LazyIgnoresConfig.from_dict() for YAML configuration loading
+
+Implementation: Enum and dataclass definitions for ignore directive representation
+"""
+
+from .config import LazyIgnoresConfig
+from .header_parser import SuppressionsParser
+from .linter import LazyIgnoresRule
+from .python_analyzer import PythonIgnoreDetector
+from .skip_detector import TestSkipDetector
+from .types import IgnoreDirective, IgnoreType, SuppressionEntry
+from .typescript_analyzer import TypeScriptIgnoreDetector
+from .violation_builder import build_orphaned_violation, build_unjustified_violation
+
+__all__ = [
+    "IgnoreType",
+    "IgnoreDirective",
+    "SuppressionEntry",
+    "LazyIgnoresConfig",
+    "PythonIgnoreDetector",
+    "TypeScriptIgnoreDetector",
+    "TestSkipDetector",
+    "SuppressionsParser",
+    "LazyIgnoresRule",
+    "build_unjustified_violation",
+    "build_orphaned_violation",
+]

src/linters/lazy_ignores/config.py

@@ -0,0 +1,66 @@
+"""
+Purpose: Configuration for lazy-ignores linter
+
+Scope: All configurable options for ignore detection
+
+Overview: Provides LazyIgnoresConfig dataclass with pattern-specific toggles for each
+    ignore type (noqa, type:ignore, pylint, nosec, typescript, eslint, thailint). Includes
+    orphaned detection toggle and file pattern ignores. Configuration can be loaded from
+    dictionary (YAML) with sensible defaults for all options.
+
+Dependencies: dataclasses, typing
+
+Exports: LazyIgnoresConfig
+
+Interfaces: LazyIgnoresConfig.from_dict() for YAML configuration loading
+
+Implementation: Dataclass with factory defaults and validation in from_dict
+
+Suppressions:
+    too-many-instance-attributes: Configuration dataclass requires many toggles
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class LazyIgnoresConfig:  # pylint: disable=too-many-instance-attributes
+    """Configuration for the lazy-ignores linter."""
+
+    # Pattern detection toggles
+    check_noqa: bool = True
+    check_type_ignore: bool = True
+    check_pylint_disable: bool = True
+    check_nosec: bool = True
+    check_ts_ignore: bool = True
+    check_eslint_disable: bool = True
+    check_thailint_ignore: bool = True
+    check_test_skips: bool = True
+
+    # Orphaned detection
+    check_orphaned: bool = True  # Header entries without matching ignores
+
+    # File patterns to ignore
+    ignore_patterns: list[str] = field(
+        default_factory=lambda: [
+            "tests/**",  # Don't enforce in test files by default
+            "**/__pycache__/**",
+        ]
+    )
+
+    @classmethod
+    def from_dict(cls, config_dict: dict[str, Any]) -> "LazyIgnoresConfig":
+        """Create config from dictionary."""
+        return cls(
+            check_noqa=config_dict.get("check_noqa", True),
+            check_type_ignore=config_dict.get("check_type_ignore", True),
+            check_pylint_disable=config_dict.get("check_pylint_disable", True),
+            check_nosec=config_dict.get("check_nosec", True),
+            check_ts_ignore=config_dict.get("check_ts_ignore", True),
+            check_eslint_disable=config_dict.get("check_eslint_disable", True),
+            check_thailint_ignore=config_dict.get("check_thailint_ignore", True),
+            check_test_skips=config_dict.get("check_test_skips", True),
+            check_orphaned=config_dict.get("check_orphaned", True),
+            ignore_patterns=config_dict.get("ignore_patterns", []),
+        )

src/linters/lazy_ignores/directive_utils.py

@@ -0,0 +1,121 @@
+"""
+Purpose: Shared utility functions for creating IgnoreDirective objects
+
+Scope: Common directive creation and path normalization for ignore detectors
+
+Overview: Provides shared utility functions used across Python, TypeScript, and test skip
+    detectors. Centralizes logic for normalizing file paths, extracting rule IDs from
+    regex matches, and creating IgnoreDirective objects to avoid code duplication.
+
+Dependencies: re for match handling, pathlib for file paths, types module for dataclasses
+
+Exports: normalize_path, extract_rule_ids, create_directive, create_directive_no_rules
+
+Interfaces: Pure utility functions with no state
+
+Implementation: Simple helper functions for directive creation
+"""
+
+import re
+from pathlib import Path
+
+from src.linters.lazy_ignores.types import IgnoreDirective, IgnoreType
+
+
+def normalize_path(file_path: Path | str | None) -> Path:
+    """Normalize file path to Path object.
+
+    Args:
+        file_path: Path object, string path, or None
+
+    Returns:
+        Path object, defaults to Path("unknown") if None
+    """
+    if file_path is None:
+        return Path("unknown")
+    if isinstance(file_path, str):
+        return Path(file_path)
+    return file_path
+
+
+def _get_captured_group(match: re.Match[str]) -> str | None:
+    """Get the first captured group from a regex match if it exists.
+
+    Args:
+        match: Regex match object
+
+    Returns:
+        Captured group text or None if no capture groups
+    """
+    if match.lastindex is None or match.lastindex < 1:
+        return None
+    return match.group(1)
+
+
+def extract_rule_ids(match: re.Match[str]) -> list[str]:
+    """Extract rule IDs from regex match group 1.
+
+    Args:
+        match: Regex match object with optional group 1 containing rule IDs
+
+    Returns:
+        List of rule ID strings, empty if no specific rules
+    """
+    group = _get_captured_group(match)
+    if not group:
+        return []
+
+    ids = [rule_id.strip() for rule_id in group.split(",")]
+    return [rule_id for rule_id in ids if rule_id]
+
+
+def create_directive(
+    match: re.Match[str],
+    ignore_type: IgnoreType,
+    line_num: int,
+    file_path: Path,
+    rule_ids: tuple[str, ...] | None = None,
+) -> IgnoreDirective:
+    """Create an IgnoreDirective from a regex match.
+
+    Args:
+        match: Regex match object
+        ignore_type: Type of ignore pattern
+        line_num: 1-indexed line number
+        file_path: Path to source file
+        rule_ids: Optional tuple of rule IDs; if None, extracts from match group 1
+
+    Returns:
+        IgnoreDirective for this match
+    """
+    if rule_ids is None:
+        rule_ids = tuple(extract_rule_ids(match))
+
+    return IgnoreDirective(
+        ignore_type=ignore_type,
+        rule_ids=rule_ids,
+        line=line_num,
+        column=match.start() + 1,
+        raw_text=match.group(0).strip(),
+        file_path=file_path,
+    )
+
+
+def create_directive_no_rules(
+    match: re.Match[str],
+    ignore_type: IgnoreType,
+    line_num: int,
+    file_path: Path,
+) -> IgnoreDirective:
+    """Create an IgnoreDirective without rule IDs (for patterns like test skips).
+
+    Args:
+        match: Regex match object
+        ignore_type: Type of ignore pattern
+        line_num: 1-indexed line number
+        file_path: Path to source file
+
+    Returns:
+        IgnoreDirective with empty rule_ids tuple
+    """
+    return create_directive(match, ignore_type, line_num, file_path, rule_ids=())

src/linters/lazy_ignores/header_parser.py

@@ -0,0 +1,177 @@
+"""
+Purpose: Parse Suppressions section from file headers
+
+Scope: Python docstrings and TypeScript JSDoc comment header parsing
+
+Overview: Provides SuppressionsParser class for extracting the Suppressions section from
+    file headers. Parses Python triple-quoted docstrings and TypeScript JSDoc comments.
+    Extracts rule IDs and justifications, normalizing rule IDs for case-insensitive matching.
+    Returns dictionary mapping normalized rule IDs to their justifications.
+
+Dependencies: re for pattern matching, Language enum for type safety
+
+Exports: SuppressionsParser
+
+Interfaces: parse(header: str) -> dict[str, str], extract_header(code: str, language: Language)
+
+Implementation: Regex-based section extraction with line-by-line entry parsing
+"""
+
+import re
+
+from src.core.constants import Language
+
+
+class SuppressionsParser:
+    """Parses Suppressions section from file headers."""
+
+    # Pattern to find Suppressions section (case-insensitive)
+    # Matches "Suppressions:" followed by indented lines
+    SUPPRESSIONS_SECTION = re.compile(
+        r"Suppressions:\s*\n((?:[ \t]+\S.*\n?)+)",
+        re.MULTILINE | re.IGNORECASE,
+    )
+
+    # Pattern for JSDoc-style suppressions (* prefixed lines)
+    JSDOC_SUPPRESSIONS_SECTION = re.compile(
+        r"Suppressions:\s*\n((?:\s*\*\s+\S.*\n?)+)",
+        re.MULTILINE | re.IGNORECASE,
+    )
+
+    # Pattern to parse individual entries (rule_id: justification)
+    # Rule IDs can contain colons (e.g., type:ignore[arg-type])
+    # Handles list prefixes: "- ", "* ", "• " and plain indented entries
+    # Justification must start with word char or underscore to avoid matching continuation lines
+    ENTRY_PATTERN = re.compile(
+        r"^\s*[-*•]?\s*(.+):\s+([A-Za-z_].*)$",
+        re.MULTILINE,
+    )
+
+    def parse(self, header: str) -> dict[str, str]:
+        """Parse Suppressions section, return rule_id -> justification mapping.
+
+        Args:
+            header: File header content (docstring or JSDoc)
+
+        Returns:
+            Dictionary mapping normalized rule IDs to justification strings
+        """
+        # Try standard Python-style first, then JSDoc-style
+        section_match = self.SUPPRESSIONS_SECTION.search(header)
+        if not section_match:
+            section_match = self.JSDOC_SUPPRESSIONS_SECTION.search(header)
+
+        if not section_match:
+            return {}
+
+        entries: dict[str, str] = {}
+        section_content = section_match.group(1)
+
+        for match in self.ENTRY_PATTERN.finditer(section_content):
+            rule_id = match.group(1).strip()
+            justification = match.group(2).strip()
+
+            # Skip entries with empty justification
+            if justification:
+                normalized_id = self.normalize_rule_id(rule_id)
+                entries[normalized_id] = justification
+
+        return entries
+
+    def normalize_rule_id(self, rule_id: str) -> str:
+        """Normalize rule ID for case-insensitive matching.
+
+        Strips common list prefixes (-, *, •) and normalizes to lowercase.
+
+        Args:
+            rule_id: Original rule ID string
+
+        Returns:
+            Normalized rule ID (lowercase, no list prefix)
+        """
+        normalized = rule_id.lower().strip()
+        # Strip common list prefixes (bullet points)
+        if normalized.startswith(("- ", "* ", "• ")):
+            normalized = normalized[2:]
+        elif normalized.startswith(("-", "*", "•")):
+            normalized = normalized[1:].lstrip()
+        return normalized
+
+    def extract_header(self, code: str, language: str | Language = Language.PYTHON) -> str:
+        """Extract the header section from code.
+
+        Args:
+            code: Full source code
+            language: Programming language (Language enum or string)
+
+        Returns:
+            Header content as string, or empty string if not found
+        """
+        lang = Language(language) if isinstance(language, str) else language
+        if lang == Language.PYTHON:
+            return self._extract_python_header(code)
+        if lang in (Language.TYPESCRIPT, Language.JAVASCRIPT):
+            return self._extract_ts_header(code)
+        return ""
+
+    def _extract_python_header(self, code: str) -> str:
+        """Extract Python docstring header.
+
+        Args:
+            code: Python source code
+
+        Returns:
+            Docstring content or empty string
+        """
+        # Match triple-quoted docstring at start of file
+        # Skip leading whitespace, comments, and encoding declarations
+        stripped = self._skip_leading_comments(code)
+
+        # Try double quotes first
+        match = re.match(r'^"""(.*?)"""', stripped, re.DOTALL)
+        if match:
+            return match.group(0)
+
+        # Try single quotes
+        match = re.match(r"^'''(.*?)'''", stripped, re.DOTALL)
+        if match:
+            return match.group(0)
+
+        return ""
+
+    def _skip_leading_comments(self, code: str) -> str:
+        """Skip leading comments and empty lines to find docstring.
+
+        Args:
+            code: Python source code
+
+        Returns:
+            Code with leading comments/empty lines removed
+        """
+        lines = code.split("\n")
+        for i, line in enumerate(lines):
+            stripped = line.strip()
+            # Skip empty lines
+            if not stripped:
+                continue
+            # Skip comment lines (including pylint/noqa/type comments)
+            if stripped.startswith("#"):
+                continue
+            # Found non-comment, non-empty line - return from here
+            return "\n".join(lines[i:])
+        return ""
+
+    def _extract_ts_header(self, code: str) -> str:
+        """Extract TypeScript/JavaScript JSDoc header.
+
+        Args:
+            code: TypeScript/JavaScript source code
+
+        Returns:
+            JSDoc comment content or empty string
+        """
+        stripped = code.lstrip()
+        match = re.match(r"^/\*\*(.*?)\*/", stripped, re.DOTALL)
+        if match:
+            return match.group(0)
+        return ""