thailint 0.5.0__py3-none-any.whl → 0.15.3__py3-none-any.whl

src/linters/file_header/violation_builder.py

@@ -1,21 +1,22 @@
 """
-File: src/linters/file_header/violation_builder.py
 Purpose: Builds violation messages for file header linter
-Exports: ViolationBuilder class
-Depends: Violation type from core
-Implements: Message templates with context-specific details
-Related: linter.py for builder usage, atemporal_detector.py for temporal violations
 
-Overview:
-    Creates formatted violation messages for file header validation failures.
+Scope: Violation message creation for file header validation failures
+
+Overview: Creates formatted violation messages for file header validation failures.
     Handles missing fields, atemporal language, and other header issues with clear,
-    actionable messages. Provides consistent violation format across all validation types.
+    actionable messages. Provides consistent violation format across all validation types
+    including rule_id, message, location, severity, and helpful suggestions. Supports
+    multiple violation types with appropriate error messages and remediation guidance.
+
+Dependencies: Violation and Severity types from core.types module
+
+Exports: ViolationBuilder class
 
-Usage:
-    builder = ViolationBuilder("file-header.validation")
-    violation = builder.build_missing_field("Purpose", "test.py", 1)
+Interfaces: build_missing_field(field_name, file_path, line) -> Violation,
+    build_atemporal_violation(pattern, description, file_path, line) -> Violation
 
-Notes: Follows standard violation format with rule_id, message, location, severity, suggestion
+Implementation: Builder pattern with message templates for different violation types
 """
 
 from src.core.types import Severity, Violation

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/directory_matcher.py

@@ -23,6 +23,10 @@ from typing import Any
 class DirectoryMatcher:
     """Finds matching directory rules based on path prefixes."""
 
+    def __init__(self) -> None:
+        """Initialize the directory matcher."""
+        pass  # Stateless matcher for directory rules
+
     def find_matching_rule(
         self, path_str: str, directories: dict[str, Any]
     ) -> tuple[dict[str, Any] | None, str | None]:

src/linters/file_placement/linter.py

@@ -6,25 +6,28 @@ Scope: Validate file organization against allow/deny patterns
 Overview: Implements file placement validation using regex patterns from JSON/YAML config.
     Orchestrates configuration loading, pattern validation, path resolution, rule checking,
     and violation creation through focused helper classes. Supports directory-specific rules,
-    global patterns, and generates helpful suggestions. Main linter class acts as coordinator.
+    global patterns, and generates helpful suggestions. Main linter class acts as coordinator
+    using composition pattern with specialized helper classes for configuration loading,
+    path resolution, pattern matching, and violation creation.
 
-Dependencies: src.core (base classes, types), pathlib, typing
+Dependencies: src.core (base classes, types), pathlib, typing, json, yaml modules
 
 Exports: FilePlacementLinter, FilePlacementRule
 
+Interfaces: lint_path(file_path) -> list[Violation], check_file_allowed(file_path) -> bool,
+    lint_directory(dir_path) -> list[Violation]
+
 Implementation: Composition pattern with helper classes for each responsibility
+    (ConfigLoader, PathResolver, PatternMatcher, PatternValidator, RuleChecker,
+    ViolationFactory)
 
-SRP Exception: FilePlacementRule has 13 methods (exceeds max 8)
-    Justification: Framework adapter class that bridges BaseLintRule interface with
-    FilePlacementLinter implementation. Must handle multiple config sources (metadata vs file),
-    multiple config formats (wrapped vs unwrapped), project root detection with fallbacks,
-    and linter caching. This complexity is inherent to adapter pattern - splitting would
-    create unnecessary indirection between framework and implementation without improving
-    maintainability. All methods are focused on the single responsibility of integrating
-    file placement validation with the linting framework.
+Suppressions:
+    - srp.violation: Rule class coordinates multiple helper classes for comprehensive
+        file placement validation. Method count reflects composition orchestration.
 """
 
 import json
+from contextlib import suppress
 from pathlib import Path
 from typing import Any
 
@@ -74,21 +77,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.
 
@@ -126,20 +139,40 @@ class FilePlacementLinter:
         Returns:
             List of all violations found
         """
-        from src.linter_config.ignore import IgnoreDirectiveParser
+        valid_files = self._get_valid_files(dir_path, recursive)
+        return self._lint_files(valid_files)
+
+    def _get_valid_files(self, dir_path: Path, recursive: bool) -> list[Path]:
+        """Get list of valid files to lint from directory.
+
+        Args:
+            dir_path: Directory to scan
+            recursive: Scan recursively
+
+        Returns:
+            List of file paths to lint
+        """
+        from src.linter_config.ignore import get_ignore_parser
 
-        ignore_parser = IgnoreDirectiveParser(self.project_root)
+        ignore_parser = get_ignore_parser(self.project_root)
         pattern = "**/*" if recursive else "*"
 
-        violations = []
-        for file_path in dir_path.glob(pattern):
-            if not file_path.is_file():
-                continue
-            if ignore_parser.is_ignored(file_path):
-                continue
-            file_violations = self.lint_path(file_path)
-            violations.extend(file_violations)
+        return [
+            f for f in dir_path.glob(pattern) if f.is_file() and not ignore_parser.is_ignored(f)
+        ]
+
+    def _lint_files(self, file_paths: list[Path]) -> list[Violation]:
+        """Lint multiple files and collect violations.
+
+        Args:
+            file_paths: List of file paths to lint
 
+        Returns:
+            List of all violations found
+        """
+        violations = []
+        for file_path in file_paths:
+            violations.extend(self.lint_path(file_path))
         return violations
 
 
@@ -295,10 +328,10 @@ class FilePlacementRule(BaseLintRule):  # thailint: ignore[srp.violation]
         if not hasattr(context, "metadata"):
             return None
         # Try hyphenated format first (original format)
-        if "file-placement" in context.metadata:
+        with suppress(KeyError):
             return context.metadata["file-placement"]
         # Try underscored format (normalized format)
-        if "file_placement" in context.metadata:
+        with suppress(KeyError):
             return context.metadata["file_placement"]
         return None
 
@@ -332,7 +365,7 @@ class FilePlacementRule(BaseLintRule):  # thailint: ignore[srp.violation]
             FilePlacementLinter instance
         """
         # Check if cached linter exists for this project root
-        if project_root in self._linter_cache:
+        with suppress(KeyError):
             return self._linter_cache[project_root]
 
         # Try to get config from context metadata (orchestrator passes config here)
@@ -388,11 +421,10 @@ class FilePlacementRule(BaseLintRule):  # thailint: ignore[srp.violation]
             config = self._parse_layout_file(layout_path)
 
             # Unwrap file-placement key if present (try both formats for backward compatibility)
-            if "file-placement" in config:
+            with suppress(KeyError):
                 return config["file-placement"]
-            if "file_placement" in config:
+            with suppress(KeyError):
                 return config["file_placement"]
-
             return config
         except Exception:
             return {}

src/linters/file_placement/pattern_matcher.py

@@ -18,30 +18,65 @@ Implementation: Uses re.search() for pattern matching with IGNORECASE flag
 """
 
 import re
+from collections.abc import Sequence
+from re import Pattern
 
 
 class PatternMatcher:
     """Handles regex pattern matching for file paths."""
 
+    def __init__(self) -> None:
+        """Initialize the pattern matcher with compiled regex cache."""
+        self._compiled_patterns: dict[str, Pattern[str]] = {}
+
+    def _get_compiled(self, pattern: str) -> Pattern[str]:
+        """Get compiled regex pattern, caching for reuse.
+
+        Args:
+            pattern: Regex pattern string
+
+        Returns:
+            Compiled regex Pattern object
+        """
+        if pattern not in self._compiled_patterns:
+            self._compiled_patterns[pattern] = re.compile(pattern, re.IGNORECASE)
+        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:
-            pattern = deny_item["pattern"]
-            if re.search(pattern, path_str, re.IGNORECASE):
-                reason = deny_item.get("reason", "File not allowed in this location")
+            pattern, reason = self._extract_pattern_and_reason(deny_item)
+            compiled = self._get_compiled(pattern)
+            if compiled.search(path_str):
                 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.
 
@@ -52,4 +87,4 @@ class PatternMatcher:
         Returns:
             True if path matches any pattern
         """
-        return any(re.search(pattern, path_str, re.IGNORECASE) for pattern in allow_patterns)
+        return any(self._get_compiled(pattern).search(path_str) for pattern in allow_patterns)

src/linters/file_placement/pattern_validator.py

@@ -18,25 +18,44 @@ Implementation: Uses re.compile() to test pattern validity, provides detailed er
 """
 
 import re
+from contextlib import suppress
 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."""
 
+    def __init__(self) -> None:
+        """Initialize the pattern validator."""
+        pass  # Stateless validator for regex patterns
+
     def validate_config(self, config: dict[str, Any]) -> None:
         """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.
@@ -58,7 +77,7 @@ class PatternValidator:
         Args:
             rules: Rules dictionary containing allow patterns
         """
-        if "allow" in rules:
+        with suppress(KeyError):
             for pattern in rules["allow"]:
                 self._validate_pattern(pattern)
 
@@ -68,9 +87,9 @@ class PatternValidator:
         Args:
             rules: Rules dictionary containing deny patterns
         """
-        if "deny" in rules:
+        with suppress(KeyError):
             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:
@@ -79,7 +98,7 @@ class PatternValidator:
         Args:
             fp_config: File placement configuration section
         """
-        if "directories" in fp_config:
+        with suppress(KeyError):
             for _dir_path, rules in fp_config["directories"].items():
                 self._validate_allow_patterns(rules)
                 self._validate_deny_patterns(rules)
@@ -90,7 +109,7 @@ class PatternValidator:
         Args:
             fp_config: File placement configuration section
         """
-        if "global_patterns" in fp_config:
+        with suppress(KeyError):
             self._validate_allow_patterns(fp_config["global_patterns"])
             self._validate_deny_patterns(fp_config["global_patterns"])
 
@@ -100,7 +119,7 @@ class PatternValidator:
         Args:
             fp_config: File placement configuration section
         """
-        if "global_deny" in fp_config:
+        with suppress(KeyError):
             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

@@ -19,6 +19,7 @@ Implementation: Checks deny before allow, delegates directory matching to Direct
     uses RuleCheckContext dataclass to reduce parameter duplication
 """
 
+from contextlib import suppress
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
@@ -76,17 +77,17 @@ class RuleChecker:
         """
         violations: list[Violation] = []
 
-        if "directories" in fp_config:
+        with suppress(KeyError):
             dir_violations = self._check_directory_rules(
                 path_str, rel_path, fp_config["directories"]
             )
             violations.extend(dir_violations)
 
-        if "global_deny" in fp_config:
+        with suppress(KeyError):
             deny_violations = self._check_global_deny(path_str, rel_path, fp_config["global_deny"])
             violations.extend(deny_violations)
 
-        if "global_patterns" in fp_config:
+        with suppress(KeyError):
             global_violations = self._check_global_patterns(
                 path_str, rel_path, fp_config["global_patterns"]
             )
@@ -177,14 +178,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
@@ -209,21 +210,25 @@ class RuleChecker:
             List of violations
         """
         # Check deny patterns first
-        if "deny" in global_patterns:
+        try:
             is_denied, reason = self.pattern_matcher.match_deny_patterns(
                 path_str, global_patterns["deny"]
             )
             if is_denied:
                 violation = self.violation_factory.create_global_deny_violation(rel_path, reason)
                 return self._wrap_violation(violation)
+        except KeyError:
+            pass  # No deny patterns
 
         # Check allow patterns
-        if "allow" in global_patterns:
+        try:
             is_allowed = self.pattern_matcher.match_allow_patterns(
                 path_str, global_patterns["allow"]
             )
             if not is_allowed:
                 violation = self.violation_factory.create_global_allow_violation(rel_path)
                 return self._wrap_violation(violation)
+        except KeyError:
+            pass  # No allow patterns
 
         return []

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,74 @@
+"""
+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, pyright, 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_pyright_ignore: 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
+
+    # Inline justification options
+    allow_inline_justifications: bool = True  # Allow " - reason" syntax
+    min_justification_length: int = 10  # Minimum chars for valid justification
+
+    # 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_pyright_ignore=config_dict.get("check_pyright_ignore", 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),
+            allow_inline_justifications=config_dict.get("allow_inline_justifications", True),
+            min_justification_length=config_dict.get("min_justification_length", 10),
+            ignore_patterns=config_dict.get("ignore_patterns", []),
+        )