thailint 0.4.4__py3-none-any.whl → 0.4.6__py3-none-any.whl

src/linters/dry/python_analyzer.py

@@ -65,8 +65,12 @@ class PythonDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.violat
         # Performance optimization: Cache parsed AST to avoid re-parsing for each hash window
         self._cached_ast: ast.Module | None = None
         self._cached_content: str | None = None
+        # Performance optimization: Line-to-node index for O(1) lookups instead of O(n) ast.walk()
+        self._line_to_nodes: dict[int, list[ast.AST]] | None = None
 
-    def analyze(self, file_path: Path, content: str, config: DRYConfig) -> list[CodeBlock]:
+    def analyze(  # thailint: ignore[nesting.excessive-depth]
+        self, file_path: Path, content: str, config: DRYConfig
+    ) -> list[CodeBlock]:
         """Analyze Python file for duplicate code blocks, excluding docstrings.
 
         Args:
@@ -81,6 +85,9 @@ class PythonDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.violat
         self._cached_ast = self._parse_content_safe(content)
         self._cached_content = content
 
+        # Performance optimization: Build line-to-node index for O(1) lookups
+        self._line_to_nodes = self._build_line_to_node_index(self._cached_ast)
+
         try:
             # Get docstring line ranges
             docstring_ranges = self._get_docstring_ranges_from_content(content)
@@ -89,34 +96,58 @@ class PythonDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.violat
             lines_with_numbers = self._tokenize_with_line_numbers(content, docstring_ranges)
 
             # Generate rolling hash windows
-            windows = self._rolling_hash_with_tracking(lines_with_numbers, config.min_duplicate_lines)
-
-            blocks = []
-            for hash_val, start_line, end_line, snippet in windows:
-                # Skip blocks that are single logical statements
-                # Check the original source code, not the normalized snippet
-                if self._is_single_statement_in_source(content, start_line, end_line):
-                    continue
-
-                block = CodeBlock(
-                    file_path=file_path,
-                    start_line=start_line,
-                    end_line=end_line,
-                    snippet=snippet,
-                    hash_value=hash_val,
-                )
-
-                # Apply extensible filters (keyword arguments, imports, etc.)
-                if self._filter_registry.should_filter_block(block, content):
-                    continue
-
-                blocks.append(block)
+            windows = self._rolling_hash_with_tracking(
+                lines_with_numbers, config.min_duplicate_lines
+            )
 
-            return blocks
+            return self._filter_valid_blocks(windows, file_path, content)
         finally:
             # Clear cache after analysis to avoid memory leaks
             self._cached_ast = None
             self._cached_content = None
+            self._line_to_nodes = None
+
+    def _filter_valid_blocks(
+        self,
+        windows: list[tuple[int, int, int, str]],
+        file_path: Path,
+        content: str,
+    ) -> list[CodeBlock]:
+        """Filter hash windows and create valid CodeBlock instances."""
+        blocks = []
+        for hash_val, start_line, end_line, snippet in windows:
+            block = self._create_block_if_valid(
+                file_path, content, hash_val, start_line, end_line, snippet
+            )
+            if block:
+                blocks.append(block)
+        return blocks
+
+    def _create_block_if_valid(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+        self,
+        file_path: Path,
+        content: str,
+        hash_val: int,
+        start_line: int,
+        end_line: int,
+        snippet: str,
+    ) -> CodeBlock | None:
+        """Create CodeBlock if it passes all validation checks."""
+        if self._is_single_statement_in_source(content, start_line, end_line):
+            return None
+
+        block = CodeBlock(
+            file_path=file_path,
+            start_line=start_line,
+            end_line=end_line,
+            snippet=snippet,
+            hash_value=hash_val,
+        )
+
+        if self._filter_registry.should_filter_block(block, content):
+            return None
+
+        return block
 
     def _get_docstring_ranges_from_content(self, content: str) -> set[int]:
         """Extract line numbers that are part of docstrings.
@@ -184,20 +215,21 @@ class PythonDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.violat
             List of (original_line_number, normalized_code) tuples
         """
         lines_with_numbers = []
+        in_multiline_import = False
 
         for line_num, line in enumerate(content.split("\n"), start=1):
-            # Skip docstring lines
             if line_num in docstring_lines:
                 continue
 
-            # Use hasher's existing tokenization logic
-            line = self._hasher._strip_comments(line)  # pylint: disable=protected-access
-            line = " ".join(line.split())
-
+            line = self._hasher._normalize_line(line)  # pylint: disable=protected-access
             if not line:
                 continue
 
-            if self._hasher._is_import_statement(line):  # pylint: disable=protected-access
+            # Update multi-line import state and check if line should be skipped
+            in_multiline_import, should_skip = self._hasher._should_skip_import_line(  # pylint: disable=protected-access
+                line, in_multiline_import
+            )
+            if should_skip:
                 continue
 
             lines_with_numbers.append((line_num, line))
@@ -243,6 +275,7 @@ class PythonDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.violat
         to avoid re-parsing the entire file for each hash window check.
         """
         # Use cached AST if available and content matches
+        tree: ast.Module | None
         if self._cached_ast is not None and content == self._cached_content:
             tree = self._cached_ast
         else:
@@ -261,23 +294,99 @@ class PythonDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.violat
         except SyntaxError:
             return None
 
-    def _check_overlapping_nodes(self, tree: ast.Module, start_line: int, end_line: int) -> bool:
-        """Check if any AST node overlaps and matches single-statement pattern.
+    @staticmethod
+    def _build_line_to_node_index(tree: ast.Module | None) -> dict[int, list[ast.AST]] | None:
+        """Build an index mapping each line number to overlapping AST nodes.
+
+        Performance optimization: This allows O(1) lookups instead of O(n) ast.walk() calls.
+        For a file with 5,144 nodes and 673 hash windows, this reduces 3.46M node operations
+        to just ~3,365 relevant node checks (99.9% reduction).
 
-        Performance optimization: Pre-filter nodes by line range before expensive pattern checks.
+        Args:
+            tree: Parsed AST tree (None if parsing failed)
+
+        Returns:
+            Dictionary mapping line numbers to list of AST nodes overlapping that line,
+            or None if tree is None
         """
+        if tree is None:
+            return None
+
+        line_to_nodes: dict[int, list[ast.AST]] = {}
         for node in ast.walk(tree):
-            # Quick line range check to skip nodes that don't overlap
-            if not hasattr(node, "lineno") or not hasattr(node, "end_lineno"):
-                continue
-            if node.end_lineno < start_line or node.lineno > end_line:
-                continue  # No overlap, skip expensive pattern matching
+            if PythonDuplicateAnalyzer._node_has_line_info(node):
+                PythonDuplicateAnalyzer._add_node_to_index(node, line_to_nodes)
+
+        return line_to_nodes
 
-            # Node overlaps - check if it matches single-statement pattern
+    @staticmethod
+    def _node_has_line_info(node: ast.AST) -> bool:
+        """Check if node has valid line number information."""
+        if not hasattr(node, "lineno") or not hasattr(node, "end_lineno"):
+            return False
+        return node.lineno is not None and node.end_lineno is not None
+
+    @staticmethod
+    def _add_node_to_index(node: ast.AST, line_to_nodes: dict[int, list[ast.AST]]) -> None:
+        """Add node to all lines it overlaps in the index."""
+        for line_num in range(node.lineno, node.end_lineno + 1):  # type: ignore[attr-defined]
+            if line_num not in line_to_nodes:
+                line_to_nodes[line_num] = []
+            line_to_nodes[line_num].append(node)
+
+    def _check_overlapping_nodes(self, tree: ast.Module, start_line: int, end_line: int) -> bool:
+        """Check if any AST node overlaps and matches single-statement pattern.
+
+        Performance optimization: Use line-to-node index for O(1) lookups instead of O(n) ast.walk().
+        """
+        if self._line_to_nodes is not None:
+            return self._check_nodes_via_index(start_line, end_line)
+        return self._check_nodes_via_walk(tree, start_line, end_line)
+
+    def _check_nodes_via_index(self, start_line: int, end_line: int) -> bool:
+        """Check nodes using line-to-node index for O(1) lookups."""
+        candidates = self._collect_candidate_nodes_from_index(start_line, end_line)
+        return self._any_node_matches_pattern(candidates, start_line, end_line)
+
+    def _collect_candidate_nodes_from_index(self, start_line: int, end_line: int) -> set[ast.AST]:
+        """Collect unique nodes that overlap with the line range from index."""
+        candidate_nodes: set[ast.AST] = set()
+        for line_num in range(start_line, end_line + 1):
+            if self._line_to_nodes and line_num in self._line_to_nodes:
+                candidate_nodes.update(self._line_to_nodes[line_num])
+        return candidate_nodes
+
+    def _any_node_matches_pattern(
+        self, nodes: set[ast.AST], start_line: int, end_line: int
+    ) -> bool:
+        """Check if any node matches single-statement pattern."""
+        for node in nodes:
             if self._is_single_statement_pattern(node, start_line, end_line):
                 return True
         return False
 
+    def _check_nodes_via_walk(self, tree: ast.Module, start_line: int, end_line: int) -> bool:
+        """Check nodes using ast.walk() fallback for tests or standalone calls."""
+        for node in ast.walk(tree):
+            if self._node_matches_via_walk(node, start_line, end_line):
+                return True
+        return False
+
+    def _node_matches_via_walk(self, node: ast.AST, start_line: int, end_line: int) -> bool:
+        """Check if a single node overlaps and matches pattern."""
+        if not self._node_overlaps_range(node, start_line, end_line):
+            return False
+        return self._is_single_statement_pattern(node, start_line, end_line)
+
+    @staticmethod
+    def _node_overlaps_range(node: ast.AST, start_line: int, end_line: int) -> bool:
+        """Check if node overlaps with the given line range."""
+        if not hasattr(node, "lineno") or not hasattr(node, "end_lineno"):
+            return False
+        node_end = node.end_lineno
+        node_start = node.lineno
+        return not (node_end < start_line or node_start > end_line)
+
     def _node_overlaps_and_matches(self, node: ast.AST, start_line: int, end_line: int) -> bool:
         """Check if node overlaps with range and matches single-statement pattern."""
         if not hasattr(node, "lineno") or not hasattr(node, "end_lineno"):

src/linters/dry/token_hasher.py

@@ -33,26 +33,80 @@ class TokenHasher:
             List of normalized code lines (non-empty, comments removed, imports filtered)
         """
         lines = []
+        in_multiline_import = False
 
         for line in code.split("\n"):
-            # Remove comments (language-specific logic can be added)
-            line = self._strip_comments(line)
-
-            # Normalize whitespace (collapse to single space)
-            line = " ".join(line.split())
-
-            # Skip empty lines
+            line = self._normalize_line(line)
             if not line:
                 continue
 
-            # Skip import statements (common false positive)
-            if self._is_import_statement(line):
+            # Update multi-line import state and check if line should be skipped
+            in_multiline_import, should_skip = self._should_skip_import_line(
+                line, in_multiline_import
+            )
+            if should_skip:
                 continue
 
             lines.append(line)
 
         return lines
 
+    def _normalize_line(self, line: str) -> str:
+        """Normalize a line by removing comments and excess whitespace.
+
+        Args:
+            line: Raw source code line
+
+        Returns:
+            Normalized line (empty string if line has no content)
+        """
+        line = self._strip_comments(line)
+        return " ".join(line.split())
+
+    def _should_skip_import_line(self, line: str, in_multiline_import: bool) -> tuple[bool, bool]:
+        """Determine if an import line should be skipped.
+
+        Args:
+            line: Normalized code line
+            in_multiline_import: Whether we're currently inside a multi-line import
+
+        Returns:
+            Tuple of (new_in_multiline_import_state, should_skip_line)
+        """
+        if self._is_multiline_import_start(line):
+            return True, True
+
+        if in_multiline_import:
+            return self._handle_multiline_import_continuation(line)
+
+        if self._is_import_statement(line):
+            return False, True
+
+        return False, False
+
+    def _is_multiline_import_start(self, line: str) -> bool:
+        """Check if line starts a multi-line import statement.
+
+        Args:
+            line: Normalized code line
+
+        Returns:
+            True if line starts a multi-line import (has opening paren but no closing)
+        """
+        return self._is_import_statement(line) and "(" in line and ")" not in line
+
+    def _handle_multiline_import_continuation(self, line: str) -> tuple[bool, bool]:
+        """Handle a line that's part of a multi-line import.
+
+        Args:
+            line: Normalized code line inside a multi-line import
+
+        Returns:
+            Tuple of (still_in_import, should_skip)
+        """
+        closes_import = ")" in line
+        return not closes_import, True
+
     def _strip_comments(self, line: str) -> str:
         """Remove comments from line (Python # and // style).
 

src/linters/dry/typescript_analyzer.py

@@ -186,20 +186,22 @@ class TypeScriptDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.vi
             List of (original_line_number, normalized_code) tuples
         """
         lines_with_numbers = []
+        in_multiline_import = False
 
         for line_num, line in enumerate(content.split("\n"), start=1):
             # Skip JSDoc comment lines
             if line_num in jsdoc_lines:
                 continue
 
-            # Use hasher's existing tokenization logic
-            line = self._hasher._strip_comments(line)  # pylint: disable=protected-access
-            line = " ".join(line.split())
-
+            line = self._hasher._normalize_line(line)  # pylint: disable=protected-access
             if not line:
                 continue
 
-            if self._hasher._is_import_statement(line):  # pylint: disable=protected-access
+            # Update multi-line import state and check if line should be skipped
+            in_multiline_import, should_skip = self._hasher._should_skip_import_line(  # pylint: disable=protected-access
+                line, in_multiline_import
+            )
+            if should_skip:
                 continue
 
             lines_with_numbers.append((line_num, line))

src/linters/file_header/__init__.py

@@ -0,0 +1,24 @@
+"""
+File: src/linters/file_header/__init__.py
+Purpose: File header linter module initialization
+Exports: FileHeaderRule
+Depends: linter.FileHeaderRule
+Implements: Module-level exports for clean API
+Related: linter.py for main rule implementation
+
+Overview:
+    Initializes the file header linter module providing multi-language file header
+    validation with mandatory field checking, atemporal language detection, and configuration
+    support. Main entry point for file header linting functionality.
+
+Usage:
+    from src.linters.file_header import FileHeaderRule
+    rule = FileHeaderRule()
+    violations = rule.check(context)
+
+Notes: Follows standard Python module initialization pattern with __all__ export control
+"""
+
+from .linter import FileHeaderRule
+
+__all__ = ["FileHeaderRule"]

src/linters/file_header/atemporal_detector.py

@@ -0,0 +1,87 @@
+"""
+File: src/linters/file_header/atemporal_detector.py
+Purpose: Detects temporal language patterns in file headers
+Exports: AtemporalDetector class
+Depends: re module for regex matching
+Implements: Regex-based pattern matching with configurable patterns
+Related: linter.py for detector usage, violation_builder.py for violation creation
+
+Overview:
+    Implements pattern-based detection of temporal language that violates atemporal
+    documentation requirements. Detects dates, temporal qualifiers, state change language,
+    and future references using regex patterns. Provides violation details for each pattern match.
+
+Usage:
+    detector = AtemporalDetector()
+    violations = detector.detect_violations(header_text)
+
+Notes: Four pattern categories - dates, temporal qualifiers, state changes, future references
+"""
+
+import re
+
+
+class AtemporalDetector:
+    """Detects temporal language patterns in text."""
+
+    # Date patterns
+    DATE_PATTERNS = [
+        (r"\d{4}-\d{2}-\d{2}", "ISO date format (YYYY-MM-DD)"),
+        (
+            r"(?:January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{4}",
+            "Month Year format",
+        ),
+        (r"(?:Created|Updated|Modified):\s*\d{4}", "Date metadata"),
+    ]
+
+    # Temporal qualifiers
+    TEMPORAL_QUALIFIERS = [
+        (r"\bcurrently\b", 'temporal qualifier "currently"'),
+        (r"\bnow\b", 'temporal qualifier "now"'),
+        (r"\brecently\b", 'temporal qualifier "recently"'),
+        (r"\bsoon\b", 'temporal qualifier "soon"'),
+        (r"\bfor now\b", 'temporal qualifier "for now"'),
+    ]
+
+    # State change language
+    STATE_CHANGE = [
+        (r"\breplaces?\b", 'state change "replaces"'),
+        (r"\bmigrated from\b", 'state change "migrated from"'),
+        (r"\bformerly\b", 'state change "formerly"'),
+        (r"\bold implementation\b", 'state change "old"'),
+        (r"\bnew implementation\b", 'state change "new"'),
+    ]
+
+    # Future references
+    FUTURE_REFS = [
+        (r"\bwill be\b", 'future reference "will be"'),
+        (r"\bplanned\b", 'future reference "planned"'),
+        (r"\bto be added\b", 'future reference "to be added"'),
+        (r"\bcoming soon\b", 'future reference "coming soon"'),
+    ]
+
+    def detect_violations(  # thailint: ignore[nesting]
+        self, text: str
+    ) -> list[tuple[str, str, int]]:
+        """Detect all temporal language violations in text.
+
+        Args:
+            text: Text to check for temporal language
+
+        Returns:
+            List of (pattern, description, line_number) tuples for each violation
+        """
+        violations = []
+
+        # Check all pattern categories
+        all_patterns = (
+            self.DATE_PATTERNS + self.TEMPORAL_QUALIFIERS + self.STATE_CHANGE + self.FUTURE_REFS
+        )
+
+        lines = text.split("\n")
+        for line_num, line in enumerate(lines, start=1):
+            for pattern, description in all_patterns:
+                if re.search(pattern, line, re.IGNORECASE):
+                    violations.append((pattern, description, line_num))
+
+        return violations

src/linters/file_header/config.py

@@ -0,0 +1,66 @@
+"""
+File: src/linters/file_header/config.py
+Purpose: Configuration model for file header linter
+Exports: FileHeaderConfig dataclass
+Depends: dataclasses, pathlib
+Implements: Configuration with validation and defaults
+Related: linter.py for configuration usage
+
+Overview:
+    Defines configuration structure for file header linter including required fields
+    per language, ignore patterns, and validation options. Provides defaults matching
+    ai-doc-standard.md requirements and supports loading from .thailint.yaml configuration.
+
+Usage:
+    config = FileHeaderConfig()
+    config = FileHeaderConfig.from_dict(config_dict, "python")
+
+Notes: Dataclass with validation and language-specific defaults
+"""
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class FileHeaderConfig:
+    """Configuration for file header linting."""
+
+    # Required fields by language
+    required_fields_python: list[str] = field(
+        default_factory=lambda: [
+            "Purpose",
+            "Scope",
+            "Overview",
+            "Dependencies",
+            "Exports",
+            "Interfaces",
+            "Implementation",
+        ]
+    )
+
+    # Enforce atemporal language checking
+    enforce_atemporal: bool = True
+
+    # Patterns to ignore (file paths)
+    ignore: list[str] = field(
+        default_factory=lambda: ["test/**", "**/migrations/**", "**/__init__.py"]
+    )
+
+    @classmethod
+    def from_dict(cls, config_dict: dict, language: str) -> "FileHeaderConfig":
+        """Create config from dictionary.
+
+        Args:
+            config_dict: Dictionary of configuration values
+            language: Programming language for language-specific config
+
+        Returns:
+            FileHeaderConfig instance with values from dictionary
+        """
+        return cls(
+            required_fields_python=config_dict.get("required_fields", {}).get(
+                "python", cls().required_fields_python
+            ),
+            enforce_atemporal=config_dict.get("enforce_atemporal", True),
+            ignore=config_dict.get("ignore", cls().ignore),
+        )

src/linters/file_header/field_validator.py

@@ -0,0 +1,69 @@
+"""
+File: src/linters/file_header/field_validator.py
+Purpose: Validates mandatory fields in file headers
+Exports: FieldValidator class
+Depends: FileHeaderConfig for field requirements
+Implements: Configuration-driven validation with field presence checking
+Related: linter.py for validator usage, config.py for configuration
+
+Overview:
+    Validates presence and quality of mandatory header fields. Checks that all
+    required fields are present, non-empty, and meet minimum content requirements.
+    Supports language-specific required fields and provides detailed violation messages.
+
+Usage:
+    validator = FieldValidator(config)
+    violations = validator.validate_fields(fields, "python")
+
+Notes: Language-specific field requirements defined in config
+"""
+
+from .config import FileHeaderConfig
+
+
+class FieldValidator:
+    """Validates mandatory fields in headers."""
+
+    def __init__(self, config: FileHeaderConfig):
+        """Initialize validator with configuration.
+
+        Args:
+            config: File header configuration with required fields
+        """
+        self.config = config
+
+    def validate_fields(  # thailint: ignore[nesting]
+        self, fields: dict[str, str], language: str
+    ) -> list[tuple[str, str]]:
+        """Validate all required fields are present.
+
+        Args:
+            fields: Dictionary of parsed header fields
+            language: File language (python, typescript, etc.)
+
+        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:
+            if field_name not in fields:
+                violations.append((field_name, f"Missing mandatory field: {field_name}"))
+            elif not fields[field_name] or len(fields[field_name].strip()) == 0:
+                violations.append((field_name, f"Empty mandatory field: {field_name}"))
+
+        return violations
+
+    def _get_required_fields(self, language: str) -> list[str]:
+        """Get required fields for language.
+
+        Args:
+            language: Programming language
+
+        Returns:
+            List of required field names for the language
+        """
+        if language == "python":
+            return self.config.required_fields_python
+        return []  # Other languages in PR5

src/linters/file_header/linter.py

@@ -0,0 +1,313 @@
+"""
+File: src/linters/file_header/linter.py
+Purpose: Main file header linter rule implementation
+Exports: FileHeaderRule class
+Depends: BaseLintRule, PythonHeaderParser, FieldValidator, AtemporalDetector, ViolationBuilder
+Implements: Composition pattern with helper classes, AST-based Python parsing
+Related: config.py for configuration, python_parser.py for extraction
+
+Overview:
+    Orchestrates file header validation for Python files using focused helper classes.
+    Coordinates docstring extraction, field validation, atemporal language detection, and
+    violation building. Supports configuration from .thailint.yaml and ignore directives.
+    Validates headers against mandatory field requirements and atemporal language standards.
+
+Usage:
+    rule = FileHeaderRule()
+    violations = rule.check(context)
+
+Notes: Follows composition pattern from magic_numbers linter for maintainability
+"""
+
+from pathlib import Path
+
+from src.core.base import BaseLintContext, BaseLintRule
+from src.core.linter_utils import load_linter_config
+from src.core.types import Violation
+from src.linter_config.ignore import IgnoreDirectiveParser
+
+from .atemporal_detector import AtemporalDetector
+from .config import FileHeaderConfig
+from .field_validator import FieldValidator
+from .python_parser import PythonHeaderParser
+from .violation_builder import ViolationBuilder
+
+
+class FileHeaderRule(BaseLintRule):  # thailint: ignore[srp]
+    """Validates file headers for mandatory fields and atemporal language.
+
+    Method count (17) exceeds SRP guideline (8) because proper A-grade complexity
+    refactoring requires extracting helper methods. Class maintains single responsibility
+    of file header validation - all methods support this core purpose through composition
+    pattern with focused helper classes (parser, validator, detector, builder).
+    """
+
+    def __init__(self) -> None:
+        """Initialize the file header rule."""
+        self._violation_builder = ViolationBuilder(self.rule_id)
+        self._ignore_parser = IgnoreDirectiveParser()
+
+    @property
+    def rule_id(self) -> str:
+        """Unique identifier for this rule.
+
+        Returns:
+            Rule identifier string
+        """
+        return "file-header.validation"
+
+    @property
+    def rule_name(self) -> str:
+        """Human-readable name for this rule.
+
+        Returns:
+            Rule name string
+        """
+        return "File Header Validation"
+
+    @property
+    def description(self) -> str:
+        """Description of what this rule checks.
+
+        Returns:
+            Rule description string
+        """
+        return "Validates file headers for mandatory fields and atemporal language"
+
+    def check(self, context: BaseLintContext) -> list[Violation]:
+        """Check file header for violations.
+
+        Args:
+            context: Lint context with file information
+
+        Returns:
+            List of violations found in file header
+        """
+        # Only Python for now (PR3), multi-language in PR5
+        if context.language != "python":
+            return []
+
+        # Check for file-level ignore directives first
+        if self._has_file_ignore(context):
+            return []
+
+        # Load configuration
+        config = self._load_config(context)
+
+        # Check if file should be ignored by pattern
+        if self._should_ignore_file(context, config):
+            return []
+
+        # Extract and validate header
+        return self._check_python_header(context, config)
+
+    def _has_file_ignore(self, context: BaseLintContext) -> bool:
+        """Check if file has file-level ignore directive.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            True if file has ignore-file directive
+        """
+        file_content = context.file_content or ""
+
+        if self._has_standard_ignore(file_content):
+            return True
+
+        return self._has_custom_ignore_syntax(file_content)
+
+    def _has_standard_ignore(self, file_content: str) -> bool:  # thailint: ignore[nesting]
+        """Check standard ignore parser for file-level ignores."""
+        # Check first 10 lines for standard ignore directives
+        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
+
+    def _has_custom_ignore_syntax(self, file_content: str) -> bool:
+        """Check custom file-level ignore syntax."""
+        first_lines = file_content.splitlines()[:10]
+        return any(self._is_ignore_line(line) for line in first_lines)
+
+    def _is_ignore_line(self, line: str) -> bool:
+        """Check if line contains ignore directive."""
+        line_lower = line.lower()
+        return "# thailint-ignore-file:" in line_lower or "# thailint-ignore" in line_lower
+
+    def _load_config(self, context: BaseLintContext) -> FileHeaderConfig:
+        """Load configuration from context.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            FileHeaderConfig with loaded or default values
+        """
+        # Try production config first
+        if hasattr(context, "metadata") and isinstance(context.metadata, dict):
+            if "file_header" in context.metadata:
+                return load_linter_config(context, "file_header", FileHeaderConfig)  # type: ignore[type-var]
+
+        # Use defaults
+        return FileHeaderConfig()
+
+    def _should_ignore_file(self, context: BaseLintContext, config: FileHeaderConfig) -> bool:
+        """Check if file matches ignore patterns.
+
+        Args:
+            context: Lint context
+            config: File header configuration
+
+        Returns:
+            True if file should be ignored
+        """
+        if not context.file_path:
+            return False
+
+        file_path = Path(context.file_path)
+        return any(self._matches_ignore_pattern(file_path, p) for p in config.ignore)
+
+    def _matches_ignore_pattern(self, file_path: Path, pattern: str) -> bool:
+        """Check if file path matches a single ignore pattern."""
+        if file_path.match(pattern):
+            return True
+
+        if self._matches_directory_pattern(file_path, pattern):
+            return True
+
+        if self._matches_file_pattern(file_path, pattern):
+            return True
+
+        return pattern in str(file_path)
+
+    def _matches_directory_pattern(self, file_path: Path, pattern: str) -> bool:
+        """Match directory patterns like **/migrations/**."""
+        if pattern.startswith("**/") and pattern.endswith("/**"):
+            dir_name = pattern[3:-3]
+            return dir_name in file_path.parts
+        return False
+
+    def _matches_file_pattern(self, file_path: Path, pattern: str) -> bool:
+        """Match file patterns like **/__init__.py."""
+        if pattern.startswith("**/"):
+            filename_pattern = pattern[3:]
+            path_str = str(file_path)
+            return file_path.name == filename_pattern or path_str.endswith(filename_pattern)
+        return False
+
+    def _check_python_header(
+        self, context: BaseLintContext, config: FileHeaderConfig
+    ) -> list[Violation]:
+        """Check Python file header.
+
+        Args:
+            context: Lint context
+            config: Configuration
+
+        Returns:
+            List of violations filtered through ignore directives
+        """
+        parser = PythonHeaderParser()
+        header = parser.extract_header(context.file_content or "")
+
+        if not header:
+            return self._build_missing_header_violations(context)
+
+        fields = parser.parse_fields(header)
+        violations = self._validate_header_fields(fields, context, config)
+        violations.extend(self._check_atemporal_violations(header, context, config))
+
+        return self._filter_ignored_violations(violations, context)
+
+    def _build_missing_header_violations(self, context: BaseLintContext) -> list[Violation]:
+        """Build violations for missing header."""
+        return [
+            self._violation_builder.build_missing_field(
+                "docstring", str(context.file_path or ""), 1
+            )
+        ]
+
+    def _validate_header_fields(
+        self, fields: dict[str, str], context: BaseLintContext, config: FileHeaderConfig
+    ) -> list[Violation]:
+        """Validate mandatory header fields."""
+        violations = []
+        field_validator = FieldValidator(config)
+        field_violations = field_validator.validate_fields(fields, context.language)
+
+        for field_name, _error_message in field_violations:
+            violations.append(
+                self._violation_builder.build_missing_field(
+                    field_name, str(context.file_path or ""), 1
+                )
+            )
+        return violations
+
+    def _check_atemporal_violations(
+        self, header: str, context: BaseLintContext, config: FileHeaderConfig
+    ) -> list[Violation]:
+        """Check for atemporal language violations."""
+        if not config.enforce_atemporal:
+            return []
+
+        violations = []
+        atemporal_detector = AtemporalDetector()
+        atemporal_violations = atemporal_detector.detect_violations(header)
+
+        for pattern, description, line_num in atemporal_violations:
+            violations.append(
+                self._violation_builder.build_atemporal_violation(
+                    pattern, description, str(context.file_path or ""), line_num
+                )
+            )
+        return violations
+
+    def _filter_ignored_violations(
+        self, violations: list[Violation], context: BaseLintContext
+    ) -> list[Violation]:
+        """Filter out violations that should be ignored.
+
+        Args:
+            violations: List of violations to filter
+            context: Lint context with file content
+
+        Returns:
+            Filtered list of violations
+        """
+        file_content = context.file_content or ""
+        lines = file_content.splitlines()
+
+        filtered = []
+        for v in violations:
+            # Check standard ignore directives
+            if self._ignore_parser.should_ignore_violation(v, file_content):
+                continue
+
+            # Check custom line-level ignore syntax: # thailint-ignore-line:
+            if self._has_line_level_ignore(lines, v):
+                continue
+
+            filtered.append(v)
+
+        return filtered
+
+    def _has_line_level_ignore(self, lines: list[str], violation: Violation) -> bool:
+        """Check for thailint-ignore-line directive.
+
+        Args:
+            lines: File content split into lines
+            violation: Violation to check
+
+        Returns:
+            True if line has ignore directive
+        """
+        if violation.line <= 0 or violation.line > len(lines):
+            return False
+
+        line_content = lines[violation.line - 1]  # Convert to 0-indexed
+        return "# thailint-ignore-line:" in line_content.lower()

src/linters/file_header/python_parser.py

@@ -0,0 +1,86 @@
+"""
+File: src/linters/file_header/python_parser.py
+Purpose: Python docstring extraction and parsing for file headers
+Exports: PythonHeaderParser class
+Depends: Python ast module
+Implements: AST-based docstring extraction with field parsing
+Related: linter.py for parser usage, field_validator.py for field validation
+
+Overview:
+    Extracts module-level docstrings from Python files using AST parsing.
+    Parses structured header fields from docstring content and handles both
+    well-formed and malformed headers. Provides field extraction and validation
+    support for FileHeaderRule.
+
+Usage:
+    parser = PythonHeaderParser()
+    header = parser.extract_header(code)
+    fields = parser.parse_fields(header)
+
+Notes: Uses ast.get_docstring() for reliable module-level docstring extraction
+"""
+
+import ast
+
+
+class PythonHeaderParser:
+    """Extracts and parses Python file headers from docstrings."""
+
+    def extract_header(self, code: str) -> str | None:
+        """Extract module-level docstring from Python code.
+
+        Args:
+            code: Python source code
+
+        Returns:
+            Module docstring or None if not found or parse error
+        """
+        try:
+            tree = ast.parse(code)
+            return ast.get_docstring(tree)
+        except SyntaxError:
+            return None
+
+    def parse_fields(self, header: str) -> dict[str, str]:  # thailint: ignore[nesting]
+        """Parse structured fields from header text.
+
+        Args:
+            header: Header docstring text
+
+        Returns:
+            Dictionary mapping field_name -> field_value
+        """
+        fields: dict[str, str] = {}
+        current_field: str | None = None
+        current_value: list[str] = []
+
+        for line in header.split("\n"):
+            if self._is_new_field_line(line):
+                current_field = self._save_and_start_new_field(
+                    fields, current_field, current_value, line
+                )
+                current_value = [line.split(":", 1)[1].strip()]
+            elif current_field:
+                current_value.append(line.strip())
+
+        self._save_current_field(fields, current_field, current_value)
+        return fields
+
+    def _is_new_field_line(self, line: str) -> bool:
+        """Check if line starts a new field."""
+        return ":" in line and not line.startswith(" ")
+
+    def _save_and_start_new_field(
+        self, fields: dict[str, str], current_field: str | None, current_value: list[str], line: str
+    ) -> str:
+        """Save current field and start new one."""
+        if current_field:
+            fields[current_field] = "\n".join(current_value).strip()
+        return line.split(":", 1)[0].strip()
+
+    def _save_current_field(
+        self, fields: dict[str, str], current_field: str | None, current_value: list[str]
+    ) -> None:
+        """Save the last field."""
+        if current_field:
+            fields[current_field] = "\n".join(current_value).strip()

src/linters/file_header/violation_builder.py

@@ -0,0 +1,78 @@
+"""
+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.
+    Handles missing fields, atemporal language, and other header issues with clear,
+    actionable messages. Provides consistent violation format across all validation types.
+
+Usage:
+    builder = ViolationBuilder("file-header.validation")
+    violation = builder.build_missing_field("Purpose", "test.py", 1)
+
+Notes: Follows standard violation format with rule_id, message, location, severity, suggestion
+"""
+
+from src.core.types import Severity, Violation
+
+
+class ViolationBuilder:
+    """Builds violation messages for file header issues."""
+
+    def __init__(self, rule_id: str):
+        """Initialize with rule ID.
+
+        Args:
+            rule_id: Rule identifier for violations
+        """
+        self.rule_id = rule_id
+
+    def build_missing_field(self, field_name: str, file_path: str, line: int = 1) -> Violation:
+        """Build violation for missing mandatory field.
+
+        Args:
+            field_name: Name of missing field
+            file_path: Path to file
+            line: Line number (default 1 for header)
+
+        Returns:
+            Violation object describing missing field
+        """
+        return Violation(
+            rule_id=self.rule_id,
+            message=f"Missing mandatory field: {field_name}",
+            file_path=file_path,
+            line=line,
+            column=1,
+            severity=Severity.ERROR,
+            suggestion=f"Add '{field_name}:' field to file header",
+        )
+
+    def build_atemporal_violation(
+        self, pattern: str, description: str, file_path: str, line: int
+    ) -> Violation:
+        """Build violation for temporal language.
+
+        Args:
+            pattern: Matched regex pattern
+            description: Description of temporal language
+            file_path: Path to file
+            line: Line number of violation
+
+        Returns:
+            Violation object describing temporal language issue
+        """
+        return Violation(
+            rule_id=self.rule_id,
+            message=f"Temporal language detected: {description}",
+            file_path=file_path,
+            line=line,
+            column=1,
+            severity=Severity.ERROR,
+            suggestion="Use present-tense factual descriptions without temporal references",
+        )

{thailint-0.4.4.dist-info → thailint-0.4.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thailint
-Version: 0.4.4
+Version: 0.4.6
 Summary: The AI Linter - Enterprise-grade linting and governance for AI-generated code across multiple languages
 License: MIT
 License-File: LICENSE
@@ -28,7 +28,7 @@ Requires-Dist: pyprojroot (>=0.3.0,<0.4.0)
 Requires-Dist: pyyaml (>=6.0,<7.0)
 Requires-Dist: tree-sitter (>=0.25.2,<0.26.0)
 Requires-Dist: tree-sitter-typescript (>=0.23.2,<0.24.0)
-Project-URL: Documentation, https://github.com/be-wise-be-kind/thai-lint#readme
+Project-URL: Documentation, https://thai-lint.readthedocs.io/
 Project-URL: Homepage, https://github.com/be-wise-be-kind/thai-lint
 Project-URL: Repository, https://github.com/be-wise-be-kind/thai-lint
 Description-Content-Type: text/markdown
@@ -37,19 +37,20 @@ Description-Content-Type: text/markdown
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
-[![Tests](https://img.shields.io/badge/tests-296%2F296%20passing-brightgreen.svg)](tests/)
+[![Tests](https://img.shields.io/badge/tests-356%2F356%20passing-brightgreen.svg)](tests/)
 [![Coverage](https://img.shields.io/badge/coverage-87%25-brightgreen.svg)](htmlcov/)
+[![Documentation Status](https://readthedocs.org/projects/thai-lint/badge/?version=latest)](https://thai-lint.readthedocs.io/en/latest/?badge=latest)
 
 The AI Linter - Enterprise-ready linting and governance for AI-generated code across multiple languages.
 
 ## Documentation
 
 **New to thailint?** Start here:
-- **[Quick Start Guide](docs/quick-start.md)** - Get running in 5 minutes
-- **[Configuration Reference](docs/configuration.md)** - Complete config options for all linters
-- **[Troubleshooting Guide](docs/troubleshooting.md)** - Common issues and solutions
+- **[Quick Start Guide](https://thai-lint.readthedocs.io/en/latest/quick-start/)** - Get running in 5 minutes
+- **[Configuration Reference](https://thai-lint.readthedocs.io/en/latest/configuration/)** - Complete config options for all linters
+- **[Troubleshooting Guide](https://thai-lint.readthedocs.io/en/latest/troubleshooting/)** - Common issues and solutions
 
-**Full Documentation:** Browse the **[docs/](docs/)** folder for comprehensive guides covering installation, all linters, configuration patterns, and integration examples.
+**Full Documentation:** Browse the **[documentation site](https://thai-lint.readthedocs.io/)** for comprehensive guides covering installation, all linters, configuration patterns, and integration examples.
 
 ## Overview
 
@@ -66,7 +67,7 @@ We're not trying to replace the wonderful existing linters like Pylint, ESLint,
 
 thailint complements your existing linting stack by catching the patterns AI tools repeatedly miss.
 
-**Complete documentation available in the [docs/](docs/) folder** covering installation, configuration, all linters, and troubleshooting.
+**Complete documentation available at [thai-lint.readthedocs.io](https://thai-lint.readthedocs.io/)** covering installation, configuration, all linters, and troubleshooting.
 
 ## Features
 
@@ -164,7 +165,7 @@ thailint dry --config .thailint.yaml src/
 thailint dry --format json src/
 ```
 
-**New to thailint?** See the **[Quick Start Guide](docs/quick-start.md)** for a complete walkthrough including config generation, understanding output, and next steps.
+**New to thailint?** See the **[Quick Start Guide](https://thai-lint.readthedocs.io/en/latest/quick-start/)** for a complete walkthrough including config generation, understanding output, and next steps.
 
 ### Library Mode
 
@@ -356,9 +357,9 @@ magic-numbers:
 }
 ```
 
-See [Configuration Guide](docs/configuration.md) for complete reference.
+See [Configuration Guide](https://thai-lint.readthedocs.io/en/latest/configuration/) for complete reference.
 
-**Need help with ignores?** See **[How to Ignore Violations](docs/how-to-ignore-violations.md)** for complete guide to all ignore levels (line, method, class, file, repository).
+**Need help with ignores?** See **[How to Ignore Violations](https://thai-lint.readthedocs.io/en/latest/how-to-ignore-violations/)** for complete guide to all ignore levels (line, method, class, file, repository).
 
 ## Nesting Depth Linter
 
@@ -444,7 +445,7 @@ Common patterns to reduce nesting:
 - **TypeScript**: Full support (if/for/while/try/switch)
 - **JavaScript**: Supported via TypeScript parser
 
-See [Nesting Linter Guide](docs/nesting-linter.md) for comprehensive documentation and refactoring patterns.
+See [Nesting Linter Guide](https://thai-lint.readthedocs.io/en/latest/nesting-linter/) for comprehensive documentation and refactoring patterns.
 
 ## Single Responsibility Principle (SRP) Linter
 
@@ -561,7 +562,7 @@ Common patterns to fix SRP violations (discovered during dogfooding):
 - **After**: Extract Class pattern applied - 5 focused classes (ConfigLoader, PatternValidator, RuleChecker, PathResolver, FilePlacementLinter)
 - **Result**: Each class ≤8 methods, ≤150 LOC, single responsibility
 
-See [SRP Linter Guide](docs/srp-linter.md) for comprehensive documentation and refactoring patterns.
+See [SRP Linter Guide](https://thai-lint.readthedocs.io/en/latest/srp-linter/) for comprehensive documentation and refactoring patterns.
 
 ## DRY Linter (Don't Repeat Yourself)
 
@@ -714,7 +715,7 @@ Built-in filters automatically exclude common non-duplication patterns:
 3. **Extract Utility Module**: Move helper functions to shared utilities
 4. **Template Method**: Use function parameters for variations
 
-See [DRY Linter Guide](docs/dry-linter.md) for comprehensive documentation, storage modes, and refactoring patterns.
+See [DRY Linter Guide](https://thai-lint.readthedocs.io/en/latest/dry-linter/) for comprehensive documentation, storage modes, and refactoring patterns.
 
 ## Magic Numbers Linter
 
@@ -866,7 +867,7 @@ def get_ports():  # thailint: ignore[magic-numbers] - Standard ports
 # thailint: ignore-file[magic-numbers]
 ```
 
-See **[How to Ignore Violations](docs/how-to-ignore-violations.md)** and **[Magic Numbers Linter Guide](docs/magic-numbers-linter.md)** for complete documentation.
+See **[How to Ignore Violations](https://thai-lint.readthedocs.io/en/latest/how-to-ignore-violations/)** and **[Magic Numbers Linter Guide](https://thai-lint.readthedocs.io/en/latest/magic-numbers-linter/)** for complete documentation.
 
 ## Pre-commit Hooks
 
@@ -928,7 +929,7 @@ repos:
         pass_filenames: true
 ```
 
-See **[Pre-commit Hooks Guide](docs/pre-commit-hooks.md)** for complete documentation, troubleshooting, and advanced configuration.
+See **[Pre-commit Hooks Guide](https://thai-lint.readthedocs.io/en/latest/pre-commit-hooks/)** for complete documentation, troubleshooting, and advanced configuration.
 
 ## Common Use Cases
 
@@ -1145,20 +1146,20 @@ docker run --rm -v /path/to/workspace:/workspace \
 
 ### Comprehensive Guides
 
-- **[Getting Started](docs/getting-started.md)** - Installation, first lint, basic config
-- **[Configuration Reference](docs/configuration.md)** - Complete config options (YAML/JSON)
-- **[How to Ignore Violations](docs/how-to-ignore-violations.md)** - Complete guide to all ignore levels
-- **[API Reference](docs/api-reference.md)** - Library API documentation
-- **[CLI Reference](docs/cli-reference.md)** - All CLI commands and options
-- **[Deployment Modes](docs/deployment-modes.md)** - CLI, Library, and Docker usage
-- **[File Placement Linter](docs/file-placement-linter.md)** - Detailed linter guide
-- **[Magic Numbers Linter](docs/magic-numbers-linter.md)** - Magic numbers detection guide
-- **[Nesting Depth Linter](docs/nesting-linter.md)** - Nesting depth analysis guide
-- **[SRP Linter](docs/srp-linter.md)** - Single Responsibility Principle guide
-- **[DRY Linter](docs/dry-linter.md)** - Duplicate code detection guide
-- **[Pre-commit Hooks](docs/pre-commit-hooks.md)** - Automated quality checks
-- **[Publishing Guide](docs/releasing.md)** - Release and publishing workflow
-- **[Publishing Checklist](docs/publishing-checklist.md)** - Post-publication validation
+- **[Getting Started](https://thai-lint.readthedocs.io/en/latest/getting-started/)** - Installation, first lint, basic config
+- **[Configuration Reference](https://thai-lint.readthedocs.io/en/latest/configuration/)** - Complete config options (YAML/JSON)
+- **[How to Ignore Violations](https://thai-lint.readthedocs.io/en/latest/how-to-ignore-violations/)** - Complete guide to all ignore levels
+- **[API Reference](https://thai-lint.readthedocs.io/en/latest/api-reference/)** - Library API documentation
+- **[CLI Reference](https://thai-lint.readthedocs.io/en/latest/cli-reference/)** - All CLI commands and options
+- **[Deployment Modes](https://thai-lint.readthedocs.io/en/latest/deployment-modes/)** - CLI, Library, and Docker usage
+- **[File Placement Linter](https://thai-lint.readthedocs.io/en/latest/file-placement-linter/)** - Detailed linter guide
+- **[Magic Numbers Linter](https://thai-lint.readthedocs.io/en/latest/magic-numbers-linter/)** - Magic numbers detection guide
+- **[Nesting Depth Linter](https://thai-lint.readthedocs.io/en/latest/nesting-linter/)** - Nesting depth analysis guide
+- **[SRP Linter](https://thai-lint.readthedocs.io/en/latest/srp-linter/)** - Single Responsibility Principle guide
+- **[DRY Linter](https://thai-lint.readthedocs.io/en/latest/dry-linter/)** - Duplicate code detection guide
+- **[Pre-commit Hooks](https://thai-lint.readthedocs.io/en/latest/pre-commit-hooks/)** - Automated quality checks
+- **[Publishing Guide](https://thai-lint.readthedocs.io/en/latest/releasing/)** - Release and publishing workflow
+- **[Publishing Checklist](https://thai-lint.readthedocs.io/en/latest/publishing-checklist/)** - Post-publication validation
 
 ### Examples
 

{thailint-0.4.4.dist-info → thailint-0.4.6.dist-info}/RECORD

@@ -30,13 +30,20 @@ src/linters/dry/duplicate_storage.py,sha256=3OxE2mtoWGAsNNrB8J2c-4JirLUoqZ9ptydO
 src/linters/dry/file_analyzer.py,sha256=ufSQ85ddsGTqGnBHZNTdV_5DGfTpUmJOB58sIdJNV0I,2928
 src/linters/dry/inline_ignore.py,sha256=ASfA-fp_1aPpkakN2e0T6qdTh8S7Jqj89ovxXJLmFlc,4439
 src/linters/dry/linter.py,sha256=XMLwCgGrFX0l0dVUJs1jpsXOfgxeKKDbxOtN5h5Emhk,5835
-src/linters/dry/python_analyzer.py,sha256=RoC_OD0UqI0j5HVEwSZWUZVyHDNUtywvxse0HRumLoI,22748
+src/linters/dry/python_analyzer.py,sha256=jmMUw2YhwkRrAJJDHaHKffGUjCiz5OzWwv_ZJrzNXqw,27367
 src/linters/dry/storage_initializer.py,sha256=ykMALFs4uMUrN0_skEwySDl_t5Dm_LGHllF0OxDhiUI,1366
-src/linters/dry/token_hasher.py,sha256=mCFuP0FQFALyKghBgZHcspsoOxgT7C7ZkfspnhFA5U4,3609
-src/linters/dry/typescript_analyzer.py,sha256=n1rsQYp7nuPhgErbG8hWawkywRz-iFGhrGlQXDrIa14,21494
+src/linters/dry/token_hasher.py,sha256=71njBzUsWvQjIWo38AKeRHQsG8K4jrjLTKuih-i6Gis,5372
+src/linters/dry/typescript_analyzer.py,sha256=ShNoB2KfPe010wKEZoFxn-ZKh0MnRUwgADDQKQtfedI,21627
 src/linters/dry/violation_builder.py,sha256=EUiEQIOZjzAoHEqZiIR8WZP8m4dgqJjcveR5mdMyClI,2803
 src/linters/dry/violation_filter.py,sha256=aTOMz8kXG2sZlSVcf3cAxgxHs7f2kBXInfr1V_04fUQ,3125
 src/linters/dry/violation_generator.py,sha256=cc6aKvTxtHSZm0F7Y-gL1bmD3JUphRmAvcbqk9aUzGg,6128
+src/linters/file_header/__init__.py,sha256=S3a2xrOlxnNWD02To5K2ZwILsNEvSj1IvUAH8RjgOV4,791
+src/linters/file_header/atemporal_detector.py,sha256=Rbjs2GHsgO-1r2kUHUuDRsX3XAX0INFZWVrKoUh5v-8,3104
+src/linters/file_header/config.py,sha256=1pjfa0hIUEiE0riMLTH9FQiETXfEkhAFuv1HBx0SGgI,2073
+src/linters/file_header/field_validator.py,sha256=bR0xZ5DhPHBE8lopbcaNwJr0auZlNDkCwml3Q8_7XOY,2380
+src/linters/file_header/linter.py,sha256=ISNnt-YMgkKQl4psVLefp5P7qTQ6wIGidq4dTkTNbaI,11228
+src/linters/file_header/python_parser.py,sha256=TcnA8OCbHK3YtixmFwSP7OCvxjjGLZBioez9wVukz28,2951
+src/linters/file_header/violation_builder.py,sha256=yDNqsZ-hDnURpph9oZNj2lCkJgd_7hprjk3Fr0iPphs,2653
 src/linters/file_placement/__init__.py,sha256=vJ43GZujcbAk-K3DwfsQZ0J3yP_5G35CKssatLyntXk,862
 src/linters/file_placement/config_loader.py,sha256=Of5sTG2S-04efn3KOlXrSxpMcC1ipBpSvCjtJOMmWno,2640
 src/linters/file_placement/directory_matcher.py,sha256=YaBeLGiT4bgqN_v4FmEmSASOBxkMC1lyEYpL17wLIDY,2607
@@ -76,8 +83,8 @@ src/orchestrator/language_detector.py,sha256=rHyVMApit80NTTNyDH1ObD1usKD8LjGmH3D
 src/templates/thailint_config_template.yaml,sha256=u8WFv2coE4uqfgf_slw7xjo4kGYIowDm1RIgxsKQzrE,4275
 src/utils/__init__.py,sha256=NiBtKeQ09Y3kuUzeN4O1JNfUIYPQDS2AP1l5ODq-Dec,125
 src/utils/project_root.py,sha256=b3YTEGTa9RPcOeHn1IByMMWyRiUabfVlpnlektL0A0o,6156
-thailint-0.4.4.dist-info/METADATA,sha256=1cmCJ3Myhrt90V0qWw-gfDr6cVP6nRO5fOZmy-TGSVY,36717
-thailint-0.4.4.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-thailint-0.4.4.dist-info/entry_points.txt,sha256=l7DQJgU18sVLDpSaXOXY3lLhnQHQIRrSJZTQjG1cEAk,62
-thailint-0.4.4.dist-info/licenses/LICENSE,sha256=kxh1J0Sb62XvhNJ6MZsVNe8PqNVJ7LHRn_EWa-T3djw,1070
-thailint-0.4.4.dist-info/RECORD,,
+thailint-0.4.6.dist-info/METADATA,sha256=3iBTAjUgiuhAv4-_oU4Bjn96LP1Xyl8tFdV8YH2NitI,37855
+thailint-0.4.6.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+thailint-0.4.6.dist-info/entry_points.txt,sha256=l7DQJgU18sVLDpSaXOXY3lLhnQHQIRrSJZTQjG1cEAk,62
+thailint-0.4.6.dist-info/licenses/LICENSE,sha256=kxh1J0Sb62XvhNJ6MZsVNe8PqNVJ7LHRn_EWa-T3djw,1070
+thailint-0.4.6.dist-info/RECORD,,