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

src/linters/file_header/field_validator.py

@@ -42,15 +42,12 @@ class FieldValidator:
         Returns:
             List of (field_name, error_message) tuples for missing/invalid fields
         """
-        violations = []
         required_fields = self._get_required_fields(language)
-
-        for field_name in required_fields:
-            error = self._check_field(fields, field_name)
-            if error:
-                violations.append(error)
-
-        return violations
+        return [
+            error
+            for field_name in required_fields
+            if (error := self._check_field(fields, field_name))
+        ]
 
     def _check_field(self, fields: dict[str, str], field_name: str) -> tuple[str, str] | None:
         """Check a single field for presence and content."""

src/linters/file_header/linter.py

@@ -20,15 +20,22 @@ Interfaces: check(context) -> list[Violation] for rule validation, standard rule
 
 Implementation: Composition pattern with helper classes for parsing, validation,
     and violation building
+
+Suppressions:
+    - type:ignore[type-var]: Protocol pattern with generic type matching
+    - srp: Rule class coordinates parsing, validation, and violation building for multiple
+        languages. Methods support single responsibility of file header validation.
 """
 
 from pathlib import Path
 from typing import Protocol
 
 from src.core.base import BaseLintContext, BaseLintRule
+from src.core.constants import HEADER_SCAN_LINES, Language
 from src.core.linter_utils import load_linter_config
 from src.core.types import Violation
-from src.linter_config.ignore import get_ignore_parser
+from src.linter_config.directive_markers import check_general_ignore, has_ignore_directive_marker
+from src.linter_config.ignore import _check_specific_rule_ignore, get_ignore_parser
 
 from .atemporal_detector import AtemporalDetector
 from .bash_parser import BashHeaderParser
@@ -111,7 +118,7 @@ class FileHeaderRule(BaseLintRule):  # thailint: ignore[srp]
             return []
 
         # Markdown has special atemporal handling
-        if context.language == "markdown":
+        if context.language == Language.MARKDOWN:
             return self._check_markdown_header(parser, context, config)
 
         return self._check_header_with_parser(parser, context, config)
@@ -158,20 +165,20 @@ class FileHeaderRule(BaseLintRule):  # thailint: ignore[srp]
 
         return self._has_custom_ignore_syntax(file_content)
 
-    def _has_standard_ignore(self, file_content: str) -> bool:  # thailint: ignore[nesting]
+    def _has_standard_ignore(self, file_content: str) -> bool:
         """Check standard ignore parser for file-level ignores."""
-        first_lines = file_content.splitlines()[:10]
-        for line in first_lines:
-            if self._ignore_parser._has_ignore_directive_marker(line):  # pylint: disable=protected-access
-                if self._ignore_parser._check_specific_rule_ignore(line, self.rule_id):  # pylint: disable=protected-access
-                    return True
-                if self._ignore_parser._check_general_ignore(line):  # pylint: disable=protected-access
-                    return True
-        return False
+        first_lines = file_content.splitlines()[:HEADER_SCAN_LINES]
+        return any(self._line_has_matching_ignore(line) for line in first_lines)
+
+    def _line_has_matching_ignore(self, line: str) -> bool:
+        """Check if line has matching ignore directive for this rule."""
+        if not has_ignore_directive_marker(line):
+            return False
+        return _check_specific_rule_ignore(line, self.rule_id) or check_general_ignore(line)
 
     def _has_custom_ignore_syntax(self, file_content: str) -> bool:
         """Check custom file-level ignore syntax."""
-        first_lines = file_content.splitlines()[:10]
+        first_lines = file_content.splitlines()[:HEADER_SCAN_LINES]
         return any(self._is_ignore_line(line) for line in first_lines)
 
     def _is_ignore_line(self, line: str) -> bool:

src/linters/file_header/markdown_parser.py

@@ -17,6 +17,12 @@ Interfaces: extract_header(code) -> str | None for frontmatter extraction,
     parse_fields(header) -> dict[str, str] for field parsing
 
 Implementation: YAML frontmatter extraction with PyYAML parsing and regex fallback for robustness
+
+Suppressions:
+    - BLE001: Broad exception catch for YAML parsing fallback (any exception triggers regex fallback)
+    - srp: Class coordinates YAML extraction, parsing, and field validation for Markdown.
+        Method count exceeds limit due to complexity refactoring.
+    - nesting,dry: _parse_simple_yaml uses nested loops for YAML structure traversal.
 """
 
 import logging

src/linters/file_placement/config_loader.py

@@ -23,6 +23,8 @@ from typing import Any
 
 import yaml
 
+from src.core.constants import CONFIG_EXTENSIONS
+
 
 class ConfigLoader:
     """Loads configuration files for file placement linter."""
@@ -79,7 +81,7 @@ class ConfigLoader:
             ValueError: If file format is unsupported
         """
         with config_path.open(encoding="utf-8") as f:
-            if config_path.suffix in [".yaml", ".yml"]:
+            if config_path.suffix in CONFIG_EXTENSIONS:
                 return yaml.safe_load(f) or {}
             if config_path.suffix == ".json":
                 return json.load(f)

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=())