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

src/linters/stringly_typed/function_call_violation_builder.py

@@ -10,9 +10,9 @@ Overview: Handles building violation objects for function calls that consistentl
 
 Dependencies: Violation, Severity, StoredFunctionCall, StringlyTypedConfig
 
-Exports: FunctionCallViolationBuilder class
+Exports: build_function_call_violations function
 
-Interfaces: FunctionCallViolationBuilder.build_violations(calls, unique_values) -> list[Violation]
+Interfaces: build_function_call_violations(calls, unique_values) -> list[Violation]
 
 Implementation: Builds violations with cross-file references and enum suggestions
 """
@@ -24,6 +24,21 @@ from src.core.types import Severity, Violation
 from .storage import StoredFunctionCall
 
 
+def build_function_call_violations(
+    calls: list[StoredFunctionCall], unique_values: set[str]
+) -> list[Violation]:
+    """Build violations for all calls to a function with limited values.
+
+    Args:
+        calls: All calls to the function/param
+        unique_values: Set of unique string values passed
+
+    Returns:
+        List of violations for each call site
+    """
+    return [_build_violation(call, calls, unique_values) for call in calls]
+
+
 def _build_cross_references(call: StoredFunctionCall, all_calls: list[StoredFunctionCall]) -> str:
     """Build cross-reference string for other function call locations.
 
@@ -42,96 +57,79 @@ def _build_cross_references(call: StoredFunctionCall, all_calls: list[StoredFunc
     return ", ".join(refs[:5])  # Limit to 5 references
 
 
-class FunctionCallViolationBuilder:
-    """Builds violations for function call patterns with limited string values."""
-
-    def build_violations(
-        self, calls: list[StoredFunctionCall], unique_values: set[str]
-    ) -> list[Violation]:
-        """Build violations for all calls to a function with limited values.
-
-        Args:
-            calls: All calls to the function/param
-            unique_values: Set of unique string values passed
-
-        Returns:
-            List of violations for each call site
-        """
-        return [self._build_violation(call, calls, unique_values) for call in calls]
-
-    def _build_violation(
-        self,
-        call: StoredFunctionCall,
-        all_calls: list[StoredFunctionCall],
-        unique_values: set[str],
-    ) -> Violation:
-        """Build a single violation for a function call.
-
-        Args:
-            call: The specific call to create violation for
-            all_calls: All calls to the same function/param
-            unique_values: Set of unique string values passed
-
-        Returns:
-            Violation instance
-        """
-        message = self._build_message(call, all_calls, unique_values)
-        suggestion = self._build_suggestion(call, unique_values)
-
-        return Violation(
-            rule_id="stringly-typed.limited-values",
-            file_path=str(call.file_path),
-            line=call.line_number,
-            column=call.column,
-            message=message,
-            severity=Severity.ERROR,
-            suggestion=suggestion,
-        )
-
-    def _build_message(
-        self,
-        call: StoredFunctionCall,
-        all_calls: list[StoredFunctionCall],
-        unique_values: set[str],
-    ) -> str:
-        """Build violation message for function call pattern.
-
-        Args:
-            call: Current function call
-            all_calls: All calls to the same function/param
-            unique_values: Set of unique values passed
-
-        Returns:
-            Human-readable violation message
-        """
-        file_count = len({c.file_path for c in all_calls})
-        values_str = ", ".join(f"'{v}'" for v in sorted(unique_values))
-        param_desc = f"parameter {call.param_index}" if call.param_index > 0 else "first parameter"
-
-        message = (
-            f"Function '{call.function_name}' {param_desc} is called with "
-            f"only {len(unique_values)} unique string values [{values_str}] "
-            f"across {file_count} file(s)."
-        )
-
-        other_refs = _build_cross_references(call, all_calls)
-        if other_refs:
-            message += f" Also called in: {other_refs}."
-
-        return message
-
-    def _build_suggestion(self, call: StoredFunctionCall, unique_values: set[str]) -> str:
-        """Build fix suggestion for function call pattern.
-
-        Args:
-            call: The function call
-            unique_values: Set of unique values passed
-
-        Returns:
-            Human-readable suggestion
-        """
-        return (
-            f"Consider defining an enum or type union with the "
-            f"{len(unique_values)} possible values for '{call.function_name}' "
-            f"parameter {call.param_index}."
-        )
+def _build_violation(
+    call: StoredFunctionCall,
+    all_calls: list[StoredFunctionCall],
+    unique_values: set[str],
+) -> Violation:
+    """Build a single violation for a function call.
+
+    Args:
+        call: The specific call to create violation for
+        all_calls: All calls to the same function/param
+        unique_values: Set of unique string values passed
+
+    Returns:
+        Violation instance
+    """
+    message = _build_message(call, all_calls, unique_values)
+    suggestion = _build_suggestion(call, unique_values)
+
+    return Violation(
+        rule_id="stringly-typed.limited-values",
+        file_path=str(call.file_path),
+        line=call.line_number,
+        column=call.column,
+        message=message,
+        severity=Severity.ERROR,
+        suggestion=suggestion,
+    )
+
+
+def _build_message(
+    call: StoredFunctionCall,
+    all_calls: list[StoredFunctionCall],
+    unique_values: set[str],
+) -> str:
+    """Build violation message for function call pattern.
+
+    Args:
+        call: Current function call
+        all_calls: All calls to the same function/param
+        unique_values: Set of unique values passed
+
+    Returns:
+        Human-readable violation message
+    """
+    file_count = len({c.file_path for c in all_calls})
+    values_str = ", ".join(f"'{v}'" for v in sorted(unique_values))
+    param_desc = f"parameter {call.param_index}" if call.param_index > 0 else "first parameter"
+
+    message = (
+        f"Function '{call.function_name}' {param_desc} is called with "
+        f"only {len(unique_values)} unique string values [{values_str}] "
+        f"across {file_count} file(s)."
+    )
+
+    other_refs = _build_cross_references(call, all_calls)
+    if other_refs:
+        message += f" Also called in: {other_refs}."
+
+    return message
+
+
+def _build_suggestion(call: StoredFunctionCall, unique_values: set[str]) -> str:
+    """Build fix suggestion for function call pattern.
+
+    Args:
+        call: The function call
+        unique_values: Set of unique values passed
+
+    Returns:
+        Human-readable suggestion
+    """
+    return (
+        f"Consider defining an enum or type union with the "
+        f"{len(unique_values)} possible values for '{call.function_name}' "
+        f"parameter {call.param_index}."
+    )

src/linters/stringly_typed/linter.py

@@ -20,6 +20,11 @@ Interfaces: StringlyTypedRule.check(context) -> list[Violation],
 
 Implementation: Two-phase pattern: check() stores data, finalize() generates violations.
     Delegates all logic to helper classes, maintains only orchestration and state.
+
+Suppressions:
+    - B101: Type narrowing assertions after guards (storage initialized, file_path/content set)
+    - srp: Rule class orchestrates cross-file detection with storage, analyzers, and generators.
+        Splitting would fragment the two-phase detection workflow.
 """
 
 from __future__ import annotations
@@ -131,7 +136,7 @@ class StringlyTypedComponents:
     typescript_analyzer: TypeScriptStringlyTypedAnalyzer
 
 
-class StringlyTypedRule(MultiLanguageLintRule):  # thailint: ignore srp
+class StringlyTypedRule(MultiLanguageLintRule):  # thailint: ignore[srp]
     """Detects stringly-typed patterns across project files.
 
     Uses two-phase pattern:
@@ -153,6 +158,19 @@ class StringlyTypedRule(MultiLanguageLintRule):  # thailint: ignore srp
             typescript_analyzer=TypeScriptStringlyTypedAnalyzer(),
         )
 
+    @property
+    def _active_storage(self) -> StringlyTypedStorage:
+        """Get storage, asserting it has been initialized.
+
+        Returns:
+            The initialized storage instance.
+
+        Raises:
+            AssertionError: If storage has not been initialized.
+        """
+        assert self._storage is not None, "Storage not initialized"  # nosec B101
+        return self._storage
+
     @property
     def rule_id(self) -> str:
         """Unique identifier for this rule."""
@@ -224,21 +242,31 @@ class StringlyTypedRule(MultiLanguageLintRule):  # thailint: ignore srp
         """
         if not self._should_analyze(context, config):
             return
+        # _should_analyze ensures file_path and file_content are set
+        assert context.file_path is not None  # nosec B101
+        assert context.file_content is not None  # nosec B101
 
-        file_path = Path(context.file_path)  # type: ignore[arg-type]
-        file_content = context.file_content or ""
         self._helpers.typescript_analyzer.config = config
-
-        # Single-parse optimization: parse once, run both trackers
         call_results, comparison_results = self._helpers.typescript_analyzer.analyze_all(
-            file_content, file_path
+            context.file_content, context.file_path
         )
+        self._store_typescript_results(call_results, comparison_results)
 
-        stored_calls = [_convert_to_stored_function_call(r) for r in call_results]
-        self._storage.add_function_calls(stored_calls)  # type: ignore[union-attr]
+    def _store_typescript_results(
+        self,
+        call_results: list[FunctionCallResult],
+        comparison_results: list[ComparisonResult],
+    ) -> None:
+        """Store TypeScript analysis results.
 
+        Args:
+            call_results: Function call patterns found
+            comparison_results: Comparison patterns found
+        """
+        stored_calls = [_convert_to_stored_function_call(r) for r in call_results]
+        self._active_storage.add_function_calls(stored_calls)
         stored_comparisons = [_convert_to_stored_comparison(r) for r in comparison_results]
-        self._storage.add_comparisons(stored_comparisons)  # type: ignore[union-attr]
+        self._active_storage.add_comparisons(stored_comparisons)
 
     def _ensure_storage_initialized(
         self, context: BaseLintContext, config: StringlyTypedConfig
@@ -263,9 +291,12 @@ class StringlyTypedRule(MultiLanguageLintRule):  # thailint: ignore srp
         """
         if not self._should_analyze(context, config):
             return
+        # _should_analyze ensures file_path and file_content are set
+        assert context.file_path is not None  # nosec B101
+        assert context.file_content is not None  # nosec B101
 
-        file_path = Path(context.file_path)  # type: ignore[arg-type]
-        file_content = context.file_content or ""
+        file_path = context.file_path
+        file_content = context.file_content
         self._helpers.python_analyzer.config = config
 
         self._store_validation_patterns(file_content, file_path)
@@ -284,8 +315,9 @@ class StringlyTypedRule(MultiLanguageLintRule):  # thailint: ignore srp
         """
         if not _is_ready_for_analysis(context, self._storage):
             return False
-        file_path = Path(context.file_path)  # type: ignore[arg-type]
-        return not is_ignored(file_path, config.ignore)
+        # _is_ready_for_analysis ensures file_path is set
+        assert context.file_path is not None  # nosec B101
+        return not is_ignored(context.file_path, config.ignore)
 
     def _store_validation_patterns(self, file_content: str, file_path: Path) -> None:
         """Analyze and store validation patterns.
@@ -295,7 +327,7 @@ class StringlyTypedRule(MultiLanguageLintRule):  # thailint: ignore srp
             file_path: Path to file
         """
         results = self._helpers.python_analyzer.analyze(file_content, file_path)
-        self._storage.add_patterns([_convert_to_stored_pattern(r) for r in results])  # type: ignore[union-attr]
+        self._active_storage.add_patterns([_convert_to_stored_pattern(r) for r in results])
 
     def _store_function_calls(self, file_content: str, file_path: Path) -> None:
         """Analyze and store function call patterns.
@@ -306,7 +338,7 @@ class StringlyTypedRule(MultiLanguageLintRule):  # thailint: ignore srp
         """
         call_results = self._helpers.python_analyzer.analyze_function_calls(file_content, file_path)
         stored_calls = [_convert_to_stored_function_call(r) for r in call_results]
-        self._storage.add_function_calls(stored_calls)  # type: ignore[union-attr]
+        self._active_storage.add_function_calls(stored_calls)
 
     def _store_comparisons(self, file_content: str, file_path: Path) -> None:
         """Analyze and store Python comparison patterns.
@@ -319,7 +351,7 @@ class StringlyTypedRule(MultiLanguageLintRule):  # thailint: ignore srp
             file_content, file_path
         )
         stored_comparisons = [_convert_to_stored_comparison(r) for r in comparison_results]
-        self._storage.add_comparisons(stored_comparisons)  # type: ignore[union-attr]
+        self._active_storage.add_comparisons(stored_comparisons)
 
     def finalize(self) -> list[Violation]:
         """Generate violations after all files processed.

src/linters/stringly_typed/python/analyzer.py

@@ -22,6 +22,10 @@ Interfaces: PythonStringlyTypedAnalyzer.analyze(code, file_path) -> list[Analysi
     PythonStringlyTypedAnalyzer.analyze_function_calls(code, file_path) -> list[FunctionCallResult]
 
 Implementation: Facade pattern coordinating multiple detectors with unified result format
+
+Suppressions:
+    - srp: Analyzer coordinates multiple detectors (membership, conditional, call tracker).
+        Facade pattern justifies combining orchestration methods.
 """
 
 import ast
@@ -120,7 +124,7 @@ class ComparisonResult:
     """Column number where the comparison starts (0-indexed)."""
 
 
-class PythonStringlyTypedAnalyzer:  # thailint: ignore srp
+class PythonStringlyTypedAnalyzer:  # thailint: ignore[srp]
     """Analyzes Python code for stringly-typed patterns.
 
     Coordinates detection of various stringly-typed patterns including membership

src/linters/stringly_typed/python/call_tracker.py

@@ -10,18 +10,24 @@ Overview: Provides FunctionCallTracker class that traverses Python AST to find f
     suggests the parameter should be an enum. Handles both simple function calls
     (foo("value")) and method calls (obj.method("value")).
 
-Dependencies: ast module for AST parsing, dataclasses for pattern structure
+Dependencies: ast module for AST parsing, dataclasses for pattern structure,
+    src.core.constants for MAX_ATTRIBUTE_CHAIN_DEPTH
 
 Exports: FunctionCallTracker class, FunctionCallPattern dataclass
 
 Interfaces: FunctionCallTracker.find_patterns(tree) -> list[FunctionCallPattern]
 
 Implementation: AST NodeVisitor pattern with Call node handling for string arguments
+
+Suppressions:
+    - invalid-name: visit_Call follows AST NodeVisitor method naming convention
 """
 
 import ast
 from dataclasses import dataclass
 
+from src.core.constants import MAX_ATTRIBUTE_CHAIN_DEPTH
+
 
 @dataclass
 class FunctionCallPattern:
@@ -119,12 +125,9 @@ class FunctionCallTracker(ast.NodeVisitor):
         """
         parts: list[str] = [node.attr]
         current = node.value
-
-        # Limit depth to avoid overly complex names
-        max_depth = 3
         depth = 0
 
-        while depth < max_depth:
+        while depth < MAX_ATTRIBUTE_CHAIN_DEPTH:
             if isinstance(current, ast.Name):
                 parts.append(current.id)
                 break

src/linters/stringly_typed/python/comparison_tracker.py

@@ -9,18 +9,26 @@ Overview: Provides ComparisonTracker class that traverses Python AST to find sca
     to multiple unique string values across files, it suggests the variable should be an enum.
     Excludes common false positives like `__name__ == "__main__"` and type name checks.
 
-Dependencies: ast module for AST parsing, dataclasses for pattern structure
+Dependencies: ast module for AST parsing, dataclasses for pattern structure,
+    src.core.constants for MAX_ATTRIBUTE_CHAIN_DEPTH
 
 Exports: ComparisonTracker class, ComparisonPattern dataclass
 
 Interfaces: ComparisonTracker.find_patterns(tree) -> list[ComparisonPattern]
 
 Implementation: AST NodeVisitor pattern with Compare node handling for string comparisons
+
+Suppressions:
+    - invalid-name: visit_Compare follows AST NodeVisitor method naming convention
+    - srp: Tracker implements AST visitor pattern with multiple visit methods.
+        Methods support single responsibility of comparison pattern detection.
 """
 
 import ast
 from dataclasses import dataclass
 
+from src.core.constants import MAX_ATTRIBUTE_CHAIN_DEPTH
+
 
 @dataclass
 class ComparisonPattern:
@@ -188,12 +196,9 @@ class ComparisonTracker(ast.NodeVisitor):  # thailint: ignore[srp]
         """
         parts: list[str] = [node.attr]
         current = node.value
-
-        # Limit depth to avoid overly complex names
-        max_depth = 3
         depth = 0
 
-        while depth < max_depth:
+        while depth < MAX_ATTRIBUTE_CHAIN_DEPTH:
             if isinstance(current, ast.Name):
                 parts.append(current.id)
                 break

src/linters/stringly_typed/python/condition_extractor.py

@@ -15,6 +15,9 @@ Exports: extract_from_condition, is_simple_string_equality, get_string_constant
 Interfaces: Functions for extracting string comparisons from AST nodes
 
 Implementation: Recursive traversal of BoolOp nodes with Compare extraction
+
+Suppressions:
+    - type:ignore[attr-defined]: AST node attribute access varies by node type (value.value)
 """
 
 import ast

src/linters/stringly_typed/python/conditional_detector.py

@@ -18,6 +18,9 @@ Exports: ConditionalPatternDetector class, EqualityChainPattern dataclass
 Interfaces: ConditionalPatternDetector.find_patterns(tree) -> list[EqualityChainPattern]
 
 Implementation: AST NodeVisitor pattern with If node chain traversal and Match statement handling
+
+Suppressions:
+    - invalid-name: visit_If, visit_Match follow AST NodeVisitor method naming convention
 """
 
 import ast
@@ -110,7 +113,7 @@ class ConditionalPatternDetector(ast.NodeVisitor):
         """
         pattern = analyze_match_statement(node, EqualityChainPattern)
         if pattern is not None:
-            self.patterns.append(pattern)  # type: ignore[arg-type]
+            self.patterns.append(pattern)
         self.generic_visit(node)
 
     def _analyze_if_chain(self, node: ast.If) -> None:

src/linters/stringly_typed/python/match_analyzer.py

@@ -17,16 +17,22 @@ Interfaces: MatchStatementAnalyzer.analyze(node) -> EqualityChainPattern | None
 Implementation: AST pattern matching for MatchValue nodes with string constants
 """
 
+from __future__ import annotations
+
 import ast
+from typing import TYPE_CHECKING
 
 from .constants import MIN_VALUES_FOR_PATTERN
 from .variable_extractor import extract_variable_name
 
+if TYPE_CHECKING:
+    from .conditional_detector import EqualityChainPattern
+
 
 def analyze_match_statement(
     node: ast.Match,
-    pattern_class: type,
-) -> object | None:
+    pattern_class: type[EqualityChainPattern],
+) -> EqualityChainPattern | None:
     """Analyze a match statement for string case patterns.
 
     Args:

src/linters/stringly_typed/python/validation_detector.py

@@ -18,6 +18,9 @@ Exports: MembershipValidationDetector class, MembershipPattern dataclass
 Interfaces: MembershipValidationDetector.find_patterns(tree) -> list[MembershipPattern]
 
 Implementation: AST NodeVisitor pattern with Compare node handling for In/NotIn operators
+
+Suppressions:
+    - invalid-name: visit_Compare follows AST NodeVisitor method naming convention
 """
 
 import ast

src/linters/stringly_typed/storage.py

@@ -1,7 +1,4 @@
 # pylint: disable=too-many-lines
-# Justification: Storage module for three related data types (patterns, function calls,
-# comparisons) with their dataclasses, conversion functions, SQL schemas, and CRUD methods.
-# Splitting into separate files would fragment cohesive SQLite storage logic.
 """
 Purpose: SQLite storage manager for stringly-typed pattern detection
 
@@ -34,6 +31,13 @@ Interfaces: StringlyTypedStorage.__init__(storage_mode), add_pattern(pattern),
 
 Implementation: SQLite with string_validations, function_calls, and string_comparisons tables,
     indexed on string_set_hash, function_name+param_index, and variable_name for performance
+
+Suppressions:
+    - too-many-lines: Storage module for three related data types with dataclasses, SQL schemas, and CRUD methods
+    - too-many-instance-attributes: StoredPattern is a pure DTO with 8 necessary fields for SQLite storage
+    - consider-using-with: NamedTemporaryFile must remain open for SQLite connection lifetime (closed in close())
+    - srp: Storage class manages SQLite for three pattern types (validations, calls, comparisons).
+        Splitting would fragment related storage operations.
 """
 
 from __future__ import annotations
@@ -44,6 +48,8 @@ import tempfile
 from dataclasses import dataclass
 from pathlib import Path
 
+from src.core.constants import StorageMode
+
 # Row index constants for SQLite query results
 _COL_FILE_PATH = 0
 _COL_LINE_NUMBER = 1
@@ -244,11 +250,8 @@ def _row_to_function_call(row: tuple) -> StoredFunctionCall:
     )
 
 
-# pylint: disable=too-many-instance-attributes
-# Justification: StoredPattern is a pure data transfer object for SQLite storage.
-# All 8 fields are necessary: file location (3), variable info (1), hash/values (3), pattern type (1).
 @dataclass
-class StoredPattern:
+class StoredPattern:  # pylint: disable=too-many-instance-attributes
     """Represents a stringly-typed pattern stored in SQLite.
 
     Captures all information needed to detect cross-file duplicates and generate
@@ -280,7 +283,7 @@ class StoredPattern:
     """Human-readable description of the detected pattern."""
 
 
-class StringlyTypedStorage:  # thailint: ignore srp
+class StringlyTypedStorage:  # thailint: ignore[srp]
     """SQLite-backed storage for stringly-typed pattern detection.
 
     Stores patterns from analyzed files and provides queries to find patterns
@@ -297,13 +300,10 @@ class StringlyTypedStorage:  # thailint: ignore srp
         self._tempfile = None
 
         # Create SQLite connection based on storage mode
-        if storage_mode == "memory":
+        if storage_mode == StorageMode.MEMORY:
             self._db = sqlite3.connect(":memory:")
-        elif storage_mode == "tempfile":
-            # pylint: disable=consider-using-with
-            # Justification: tempfile must remain open for SQLite connection lifetime.
-            # It is explicitly closed in close() method when storage is finalized.
-            self._tempfile = tempfile.NamedTemporaryFile(suffix=".db", delete=True)
+        elif storage_mode == StorageMode.TEMPFILE:
+            self._tempfile = tempfile.NamedTemporaryFile(suffix=".db", delete=True)  # pylint: disable=consider-using-with
             self._db = sqlite3.connect(self._tempfile.name)
         else:
             raise ValueError(f"Invalid storage_mode: {storage_mode}")

src/linters/stringly_typed/typescript/call_tracker.py

@@ -11,19 +11,26 @@ Overview: Provides TypeScriptCallTracker class that uses tree-sitter to traverse
     function calls (foo("value")) and method calls (obj.method("value")), including
     chained method calls.
 
-Dependencies: TypeScriptBaseAnalyzer for tree-sitter parsing, dataclasses for pattern structure
+Dependencies: TypeScriptBaseAnalyzer for tree-sitter parsing, dataclasses for pattern structure,
+    src.core.constants for MAX_ATTRIBUTE_CHAIN_DEPTH
 
 Exports: TypeScriptCallTracker class, TypeScriptFunctionCallPattern dataclass
 
 Interfaces: TypeScriptCallTracker.find_patterns(code) -> list[TypeScriptFunctionCallPattern]
 
 Implementation: Tree-sitter node traversal with call_expression node handling for string arguments
+
+Suppressions:
+    - type:ignore[assignment,misc]: Tree-sitter Node type alias (optional dependency fallback)
+    - srp: Tracker implements tree-sitter traversal with helper methods for call extraction.
+        Methods support single responsibility of function call pattern detection.
 """
 
 from dataclasses import dataclass
 from typing import Any
 
 from src.analyzers.typescript_base import TREE_SITTER_AVAILABLE, TypeScriptBaseAnalyzer
+from src.core.constants import MAX_ATTRIBUTE_CHAIN_DEPTH
 
 if TREE_SITTER_AVAILABLE:
     from tree_sitter import Node
@@ -180,10 +187,9 @@ class TypeScriptCallTracker(TypeScriptBaseAnalyzer):  # thailint: ignore[srp]
             Qualified function name or None if too complex
         """
         parts: list[str] = []
-        max_depth = 3
         current: Node | None = node
 
-        for _ in range(max_depth):
+        for _ in range(MAX_ATTRIBUTE_CHAIN_DEPTH):
             if current is None:
                 break
             self._add_property_name(current, parts)

src/linters/stringly_typed/typescript/comparison_tracker.py

@@ -10,7 +10,8 @@ Overview: Provides TypeScriptComparisonTracker class that uses tree-sitter to tr
     it suggests the variable should be an enum. Excludes common false positives like template
     literals and typeof comparisons.
 
-Dependencies: TypeScriptBaseAnalyzer for tree-sitter parsing, dataclasses for pattern structure
+Dependencies: TypeScriptBaseAnalyzer for tree-sitter parsing, dataclasses for pattern structure,
+    src.core.constants for MAX_ATTRIBUTE_CHAIN_DEPTH
 
 Exports: TypeScriptComparisonTracker class, TypeScriptComparisonPattern dataclass
 
@@ -18,12 +19,18 @@ Interfaces: TypeScriptComparisonTracker.find_patterns(code) -> list[TypeScriptCo
 
 Implementation: Tree-sitter node traversal with binary_expression node handling for string
     comparisons
+
+Suppressions:
+    - type:ignore[assignment,misc]: Tree-sitter Node type alias (optional dependency fallback)
+    - srp: Tracker implements tree-sitter traversal with helper methods for node extraction.
+        Methods support single responsibility of comparison pattern detection.
 """
 
 from dataclasses import dataclass
 from typing import Any
 
 from src.analyzers.typescript_base import TREE_SITTER_AVAILABLE, TypeScriptBaseAnalyzer
+from src.core.constants import MAX_ATTRIBUTE_CHAIN_DEPTH
 
 if TREE_SITTER_AVAILABLE:
     from tree_sitter import Node
@@ -277,10 +284,9 @@ class TypeScriptComparisonTracker(TypeScriptBaseAnalyzer):  # thailint: ignore[s
             Qualified name or None if too complex
         """
         parts: list[str] = []
-        max_depth = 3
         current: Node | None = node
 
-        for _ in range(max_depth):
+        for _ in range(MAX_ATTRIBUTE_CHAIN_DEPTH):
             if current is None:
                 break
             self._add_property_name(current, parts)