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

src/linters/dry/typescript_statement_detector.py

@@ -10,246 +10,246 @@ Overview: Provides sophisticated single-statement pattern detection to filter fa
 
 Dependencies: tree-sitter for TypeScript AST parsing
 
-Exports: TypeScriptStatementDetector class
+Exports: is_single_statement, should_include_block functions
 
-Interfaces: TypeScriptStatementDetector.is_single_statement(content, start_line, end_line) -> bool
+Interfaces: is_single_statement(content, start_line, end_line) -> bool,
+    should_include_block(content, start_line, end_line) -> bool
 
 Implementation: Tree-sitter AST walking with pattern matching for TypeScript constructs
 
-SRP Exception: TypeScriptStatementDetector has 20 methods (exceeds max 8 methods)
-    Justification: Complex tree-sitter AST analysis algorithm for single-statement pattern detection.
-    Methods form tightly coupled algorithm pipeline: decorator detection, call expression analysis,
-    declaration patterns, JSX element handling, class body field definitions, and interface filtering.
-    Similar to parser or compiler pass architecture where algorithmic cohesion is critical. Splitting
-    would fragment the algorithm logic and make maintenance harder by separating interdependent
-    tree-sitter AST analysis steps. All methods contribute to single responsibility: accurately
-    detecting single-statement patterns to prevent false positives in TypeScript duplicate detection.
+Suppressions:
+    - type:ignore[assignment,misc]: Tree-sitter Node type alias (optional dependency fallback)
 """
 
 from collections.abc import Generator
+from typing import Any
 
 from src.analyzers.typescript_base import TREE_SITTER_AVAILABLE
 
 if TREE_SITTER_AVAILABLE:
     from tree_sitter import Node
 else:
-    Node = None  # type: ignore[assignment,misc]  # pylint: disable=invalid-name
+    Node = Any  # type: ignore[assignment,misc]
 
 
-class TypeScriptStatementDetector:  # thailint: ignore[srp.violation]
-    """Detects single-statement patterns in TypeScript/JavaScript for duplicate filtering.
+def is_single_statement(content: str, start_line: int, end_line: int) -> bool:
+    """Check if a line range is a single logical statement.
 
-    SRP suppression: Complex tree-sitter AST analysis algorithm requires 20 methods to implement
-    sophisticated single-statement detection. See file header for justification.
+    Args:
+        content: TypeScript source code
+        start_line: Starting line number (1-indexed)
+        end_line: Ending line number (1-indexed)
+
+    Returns:
+        True if this range represents a single logical statement/expression
     """
+    if not TREE_SITTER_AVAILABLE:
+        return False
 
-    def is_single_statement(self, content: str, start_line: int, end_line: int) -> bool:
-        """Check if a line range is a single logical statement.
+    from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
 
-        Args:
-            content: TypeScript source code
-            start_line: Starting line number (1-indexed)
-            end_line: Ending line number (1-indexed)
+    analyzer = TypeScriptBaseAnalyzer()
+    root = analyzer.parse_typescript(content)
+    if not root:
+        return False
 
-        Returns:
-            True if this range represents a single logical statement/expression
-        """
-        if not TREE_SITTER_AVAILABLE:
-            return False
+    return _check_overlapping_nodes(root, start_line, end_line)
 
-        from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
 
-        analyzer = TypeScriptBaseAnalyzer()
-        root = analyzer.parse_typescript(content)
-        if not root:
-            return False
+def should_include_block(content: str, start_line: int, end_line: int) -> bool:
+    """Check if block should be included (not overlapping interface definitions).
 
-        return self._check_overlapping_nodes(root, start_line, end_line)
+    Args:
+        content: File content
+        start_line: Block start line
+        end_line: Block end line
 
-    def _check_overlapping_nodes(self, root: Node, start_line: int, end_line: int) -> bool:
-        """Check if any AST node overlaps and matches single-statement pattern."""
-        ts_start = start_line - 1  # Convert to 0-indexed
-        ts_end = end_line - 1
+    Returns:
+        False if block overlaps interface definition, True otherwise
+    """
+    interface_ranges = _find_interface_ranges(content)
+    return not _overlaps_interface(start_line, end_line, interface_ranges)
 
-        for node in self._walk_nodes(root):
-            if self._node_overlaps_and_matches(node, ts_start, ts_end):
-                return True
-        return False
 
-    def _walk_nodes(self, node: Node) -> Generator[Node, None, None]:
-        """Generator to walk all nodes in tree."""
-        yield node
-        for child in node.children:
-            yield from self._walk_nodes(child)
-
-    def _node_overlaps_and_matches(self, node: Node, ts_start: int, ts_end: int) -> bool:
-        """Check if node overlaps with range and matches single-statement pattern."""
-        node_start = node.start_point[0]
-        node_end = node.end_point[0]
-
-        overlaps = not (node_end < ts_start or node_start > ts_end)
-        if not overlaps:
-            return False
-
-        return self._is_single_statement_pattern(node, ts_start, ts_end)
-
-    def _is_single_statement_pattern(self, node: Node, ts_start: int, ts_end: int) -> bool:
-        """Check if an AST node represents a single-statement pattern to filter."""
-        node_start = node.start_point[0]
-        node_end = node.end_point[0]
-        contains = (node_start <= ts_start) and (node_end >= ts_end)
-
-        matchers = [
-            self._matches_simple_container_pattern(node, contains),
-            self._matches_call_expression_pattern(node, ts_start, ts_end, contains),
-            self._matches_declaration_pattern(node, contains),
-            self._matches_jsx_pattern(node, contains),
-            self._matches_class_body_pattern(node, ts_start, ts_end),
-        ]
-        return any(matchers)
-
-    def _matches_simple_container_pattern(self, node: Node, contains: bool) -> bool:
-        """Check if node is a simple container pattern (decorator, object, etc.)."""
-        simple_types = (
-            "decorator",
-            "object",
-            "member_expression",
-            "as_expression",
-            "array_pattern",
-        )
-        return node.type in simple_types and contains
-
-    def _matches_call_expression_pattern(
-        self, node: Node, ts_start: int, ts_end: int, contains: bool
-    ) -> bool:
-        """Check if node is a call expression pattern."""
-        if node.type != "call_expression":
-            return False
-
-        node_start = node.start_point[0]
-        node_end = node.end_point[0]
-        is_multiline = node_start < node_end
-        if is_multiline and node_start <= ts_start <= node_end:
-            return True
+def _check_overlapping_nodes(root: Node, start_line: int, end_line: int) -> bool:
+    """Check if any AST node overlaps and matches single-statement pattern."""
+    ts_start = start_line - 1  # Convert to 0-indexed
+    ts_end = end_line - 1
 
-        return contains
+    return any(_node_overlaps_and_matches(node, ts_start, ts_end) for node in _walk_nodes(root))
 
-    def _matches_declaration_pattern(self, node: Node, contains: bool) -> bool:
-        """Check if node is a lexical declaration pattern."""
-        if node.type != "lexical_declaration" or not contains:
-            return False
 
-        if self._contains_function_body(node):
-            return False
+def _walk_nodes(node: Node) -> Generator[Node, None, None]:
+    """Generator to walk all nodes in tree."""
+    yield node
+    for child in node.children:
+        yield from _walk_nodes(child)
+
+
+def _node_overlaps_and_matches(node: Node, ts_start: int, ts_end: int) -> bool:
+    """Check if node overlaps with range and matches single-statement pattern."""
+    node_start = node.start_point[0]
+    node_end = node.end_point[0]
+
+    overlaps = not (node_end < ts_start or node_start > ts_end)
+    if not overlaps:
+        return False
+
+    return _is_single_statement_pattern(node, ts_start, ts_end)
+
+
+def _is_single_statement_pattern(node: Node, ts_start: int, ts_end: int) -> bool:
+    """Check if an AST node represents a single-statement pattern to filter."""
+    node_start = node.start_point[0]
+    node_end = node.end_point[0]
+    contains = (node_start <= ts_start) and (node_end >= ts_end)
+
+    matchers = [
+        _matches_simple_container_pattern(node, contains),
+        _matches_call_expression_pattern(node, ts_start, ts_end, contains),
+        _matches_declaration_pattern(node, contains),
+        _matches_jsx_pattern(node, contains),
+        _matches_class_body_pattern(node, ts_start, ts_end),
+    ]
+    return any(matchers)
+
+
+def _matches_simple_container_pattern(node: Node, contains: bool) -> bool:
+    """Check if node is a simple container pattern (decorator, object, etc.)."""
+    simple_types = (
+        "decorator",
+        "object",
+        "member_expression",
+        "as_expression",
+        "array_pattern",
+    )
+    return node.type in simple_types and contains
+
+
+def _matches_call_expression_pattern(
+    node: Node, ts_start: int, ts_end: int, contains: bool
+) -> bool:
+    """Check if node is a call expression pattern."""
+    if node.type != "call_expression":
+        return False
 
+    node_start = node.start_point[0]
+    node_end = node.end_point[0]
+    is_multiline = node_start < node_end
+    if is_multiline and node_start <= ts_start <= node_end:
         return True
 
-    def _matches_jsx_pattern(self, node: Node, contains: bool) -> bool:
-        """Check if node is a JSX element pattern."""
-        jsx_types = ("jsx_opening_element", "jsx_self_closing_element")
-        return node.type in jsx_types and contains
-
-    def _matches_class_body_pattern(self, node: Node, ts_start: int, ts_end: int) -> bool:
-        """Check if node is a class body field definition pattern."""
-        if node.type != "class_body":
-            return False
-
-        return self._is_in_class_field_area(node, ts_start, ts_end)
-
-    def _contains_function_body(self, node: Node) -> bool:
-        """Check if node contains an arrow function or function expression."""
-        for child in node.children:
-            if child.type in ("arrow_function", "function", "function_expression"):
-                return True
-            if self._contains_function_body(child):
-                return True
+    return contains
+
+
+def _matches_declaration_pattern(node: Node, contains: bool) -> bool:
+    """Check if node is a lexical declaration pattern."""
+    if node.type != "lexical_declaration" or not contains:
+        return False
+
+    if _contains_function_body(node):
         return False
 
-    def _find_first_method_line(self, class_body: Node) -> int | None:
-        """Find line number of first method in class body."""
-        for child in class_body.children:
-            if child.type in ("method_definition", "function_declaration"):
-                return child.start_point[0]
-        return None
-
-    def _is_in_class_field_area(self, class_body: Node, ts_start: int, ts_end: int) -> bool:
-        """Check if range is in class field definition area (before methods)."""
-        first_method_line = self._find_first_method_line(class_body)
-        class_start = class_body.start_point[0]
-        class_end = class_body.end_point[0]
-
-        if first_method_line is None:
-            return class_start <= ts_start and class_end >= ts_end
-
-        return class_start <= ts_start and ts_end < first_method_line
-
-    def should_include_block(self, content: str, start_line: int, end_line: int) -> bool:
-        """Check if block should be included (not overlapping interface definitions).
-
-        Args:
-            content: File content
-            start_line: Block start line
-            end_line: Block end line
-
-        Returns:
-            False if block overlaps interface definition, True otherwise
-        """
-        interface_ranges = self._find_interface_ranges(content)
-        return not self._overlaps_interface(start_line, end_line, interface_ranges)
-
-    def _find_interface_ranges(self, content: str) -> list[tuple[int, int]]:
-        """Find line ranges of interface/type definitions."""
-        ranges: list[tuple[int, int]] = []
-        lines = content.split("\n")
-        state = {"in_interface": False, "start_line": 0, "brace_count": 0}
-
-        for i, line in enumerate(lines, start=1):
-            stripped = line.strip()
-            self._process_line_for_interface(stripped, i, state, ranges)
-
-        return ranges
-
-    def _process_line_for_interface(
-        self, stripped: str, line_num: int, state: dict, ranges: list[tuple[int, int]]
-    ) -> None:
-        """Process single line for interface detection."""
-        if self._is_interface_start(stripped):
-            self._handle_interface_start(stripped, line_num, state, ranges)
-            return
-
-        if state["in_interface"]:
-            self._handle_interface_continuation(stripped, line_num, state, ranges)
-
-    def _is_interface_start(self, stripped: str) -> bool:
-        """Check if line starts interface/type definition."""
-        return stripped.startswith(("interface ", "type ")) and "{" in stripped
-
-    def _handle_interface_start(
-        self, stripped: str, line_num: int, state: dict, ranges: list[tuple[int, int]]
-    ) -> None:
-        """Handle start of interface definition."""
-        state["in_interface"] = True
-        state["start_line"] = line_num
-        state["brace_count"] = stripped.count("{") - stripped.count("}")
-
-        if state["brace_count"] == 0:
-            ranges.append((line_num, line_num))
-            state["in_interface"] = False
-
-    def _handle_interface_continuation(
-        self, stripped: str, line_num: int, state: dict, ranges: list[tuple[int, int]]
-    ) -> None:
-        """Handle continuation of interface definition."""
-        state["brace_count"] += stripped.count("{") - stripped.count("}")
-        if state["brace_count"] == 0:
-            ranges.append((state["start_line"], line_num))
-            state["in_interface"] = False
-
-    def _overlaps_interface(
-        self, start: int, end: int, interface_ranges: list[tuple[int, int]]
-    ) -> bool:
-        """Check if block overlaps with any interface range."""
-        for if_start, if_end in interface_ranges:
-            if start <= if_end and end >= if_start:
-                return True
+    return True
+
+
+def _matches_jsx_pattern(node: Node, contains: bool) -> bool:
+    """Check if node is a JSX element pattern."""
+    jsx_types = ("jsx_opening_element", "jsx_self_closing_element")
+    return node.type in jsx_types and contains
+
+
+def _matches_class_body_pattern(node: Node, ts_start: int, ts_end: int) -> bool:
+    """Check if node is a class body field definition pattern."""
+    if node.type != "class_body":
         return False
+
+    return _is_in_class_field_area(node, ts_start, ts_end)
+
+
+def _contains_function_body(node: Node) -> bool:
+    """Check if node contains an arrow function or function expression."""
+    for child in node.children:
+        if child.type in ("arrow_function", "function", "function_expression"):
+            return True
+        if _contains_function_body(child):
+            return True
+    return False
+
+
+def _find_first_method_line(class_body: Node) -> int | None:
+    """Find line number of first method in class body."""
+    for child in class_body.children:
+        if child.type in ("method_definition", "function_declaration"):
+            return child.start_point[0]
+    return None
+
+
+def _is_in_class_field_area(class_body: Node, ts_start: int, ts_end: int) -> bool:
+    """Check if range is in class field definition area (before methods)."""
+    first_method_line = _find_first_method_line(class_body)
+    class_start = class_body.start_point[0]
+    class_end = class_body.end_point[0]
+
+    if first_method_line is None:
+        return class_start <= ts_start and class_end >= ts_end
+
+    return class_start <= ts_start and ts_end < first_method_line
+
+
+def _find_interface_ranges(content: str) -> list[tuple[int, int]]:
+    """Find line ranges of interface/type definitions."""
+    ranges: list[tuple[int, int]] = []
+    lines = content.split("\n")
+    state = {"in_interface": False, "start_line": 0, "brace_count": 0}
+
+    for i, line in enumerate(lines, start=1):
+        stripped = line.strip()
+        _process_line_for_interface(stripped, i, state, ranges)
+
+    return ranges
+
+
+def _process_line_for_interface(
+    stripped: str, line_num: int, state: dict[str, Any], ranges: list[tuple[int, int]]
+) -> None:
+    """Process single line for interface detection."""
+    if _is_interface_start(stripped):
+        _handle_interface_start(stripped, line_num, state, ranges)
+        return
+
+    if state["in_interface"]:
+        _handle_interface_continuation(stripped, line_num, state, ranges)
+
+
+def _is_interface_start(stripped: str) -> bool:
+    """Check if line starts interface/type definition."""
+    return stripped.startswith(("interface ", "type ")) and "{" in stripped
+
+
+def _handle_interface_start(
+    stripped: str, line_num: int, state: dict[str, Any], ranges: list[tuple[int, int]]
+) -> None:
+    """Handle start of interface definition."""
+    state["in_interface"] = True
+    state["start_line"] = line_num
+    state["brace_count"] = stripped.count("{") - stripped.count("}")
+
+    if state["brace_count"] == 0:
+        ranges.append((line_num, line_num))
+        state["in_interface"] = False
+
+
+def _handle_interface_continuation(
+    stripped: str, line_num: int, state: dict[str, Any], ranges: list[tuple[int, int]]
+) -> None:
+    """Handle continuation of interface definition."""
+    state["brace_count"] += stripped.count("{") - stripped.count("}")
+    if state["brace_count"] == 0:
+        ranges.append((state["start_line"], line_num))
+        state["in_interface"] = False
+
+
+def _overlaps_interface(start: int, end: int, interface_ranges: list[tuple[int, int]]) -> bool:
+    """Check if block overlaps with any interface range."""
+    return any(start <= if_end and end >= if_start for if_start, if_end in interface_ranges)

src/linters/dry/typescript_value_extractor.py

@@ -14,6 +14,9 @@ Exports: TypeScriptValueExtractor class
 Interfaces: TypeScriptValueExtractor.get_value_string(node, content) -> str | None
 
 Implementation: Tree-sitter node traversal with type-specific string formatting
+
+Suppressions:
+    - type:ignore[assignment,misc]: Tree-sitter Node type alias (optional dependency fallback)
 """
 
 from typing import Any

src/linters/dry/violation_filter.py

@@ -54,10 +54,7 @@ class ViolationFilter:
         Returns:
             True if violation overlaps with any kept violation
         """
-        for kept in kept_violations:
-            if self._overlaps(violation, kept):
-                return True
-        return False
+        return any(self._overlaps(violation, kept) for kept in kept_violations)
 
     def _overlaps(self, v1: Violation, v2: Violation) -> bool:
         """Check if two violations overlap.

src/linters/dry/violation_generator.py

@@ -128,10 +128,7 @@ class ViolationGenerator:
             True if file should be ignored
         """
         path_str = str(Path(file_path))
-        for pattern in ignore_patterns:
-            if pattern in path_str:
-                return True
-        return False
+        return any(pattern in path_str for pattern in ignore_patterns)
 
     def _filter_inline_ignored(
         self, violations: list[Violation], inline_ignore: InlineIgnoreParser

src/linters/file_header/atemporal_detector.py

@@ -15,50 +15,68 @@ Exports: AtemporalDetector class with detect_violations method
 
 Interfaces: detect_violations(text) -> list[tuple[str, str, int]] returns pattern matches with line numbers
 
-Implementation: Regex-based pattern matching with predefined patterns organized by category
+Implementation: Regex-based pattern matching with pre-compiled patterns organized by category
+
+Suppressions:
+    - nesting: detect_violations iterates over pattern categories and their patterns.
+        Natural grouping by category requires nested loops.
 """
 
 import re
+from re import Pattern
+
+
+def _compile_patterns(patterns: list[tuple[str, str]]) -> list[tuple[Pattern[str], str]]:
+    """Compile regex patterns for efficient reuse."""
+    return [(re.compile(pattern, re.IGNORECASE), desc) for pattern, desc in patterns]
 
 
 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"'),
-    ]
+    # Pre-compiled date patterns
+    DATE_PATTERNS = _compile_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"),
+        ]
+    )
+
+    # Pre-compiled temporal qualifiers
+    TEMPORAL_QUALIFIERS = _compile_patterns(
+        [
+            (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"'),
+        ]
+    )
+
+    # Pre-compiled state change language
+    STATE_CHANGE = _compile_patterns(
+        [
+            (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"'),
+        ]
+    )
+
+    # Pre-compiled future references
+    FUTURE_REFS = _compile_patterns(
+        [
+            (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
@@ -73,15 +91,15 @@ class AtemporalDetector:
         """
         violations = []
 
-        # Check all pattern categories
+        # Check all pattern categories (patterns are pre-compiled)
         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))
+            for compiled_pattern, description in all_patterns:
+                if compiled_pattern.search(line):
+                    violations.append((compiled_pattern.pattern, description, line_num))
 
         return violations

src/linters/file_header/base_parser.py

@@ -16,6 +16,10 @@ Exports: BaseHeaderParser abstract base class
 Interfaces: extract_header(code) abstract method, parse_fields(header) -> dict[str, str] for field extraction
 
 Implementation: Template method pattern with shared field parsing and language-specific extraction
+
+Suppressions:
+    - nesting: parse_fields uses nested loops for multi-line field processing. Extracting
+        would fragment the field-building logic without improving clarity.
 """
 
 import re

src/linters/file_header/bash_parser.py

@@ -16,6 +16,10 @@ Exports: BashHeaderParser class
 Interfaces: extract_header(code) -> str | None for comment extraction, parse_fields(header) inherited from base
 
 Implementation: Skips shebang and preamble, then extracts contiguous hash comment block
+
+Suppressions:
+    - nesting: _skip_preamble uses conditional loops for shebang/preamble detection.
+        Sequential line processing requires nested state checks.
 """
 
 from src.linters.file_header.base_parser import BaseHeaderParser

src/linters/file_header/config.py

@@ -111,6 +111,20 @@ class FileHeaderConfig:
         defaults = cls()
         required_fields = config_dict.get("required_fields", {})
 
+        # Handle both list format (applies to all languages) and dict format (language-specific)
+        if isinstance(required_fields, list):
+            # Simple list format: apply same fields to all languages
+            return cls(
+                required_fields_python=required_fields,
+                required_fields_typescript=required_fields,
+                required_fields_bash=required_fields,
+                required_fields_markdown=required_fields,
+                required_fields_css=required_fields,
+                enforce_atemporal=config_dict.get("enforce_atemporal", True),
+                ignore=config_dict.get("ignore", defaults.ignore),
+            )
+
+        # Dict format: language-specific fields
         return cls(
             required_fields_python=required_fields.get("python", defaults.required_fields_python),
             required_fields_typescript=required_fields.get(