thailint 0.15.2__tar.gz → 0.15.3__tar.gz

{thailint-0.15.2 → thailint-0.15.3}/CHANGELOG.md

@@ -27,6 +27,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - **Stateless Class Linter** - Detect Python classes without state that should be module-level functions
+
+## [0.15.3] - 2026-01-26
+
+### Fixed
+
+- **DRY Linter**: Ignore directives (`# thailint: ignore-start dry` / `ignore-end`) now work correctly for both duplicate code and duplicate constant detection (#144)
   - AST-based detection of classes without `__init__`/`__new__` constructors
   - Detects classes without instance state (`self.attr` assignments)
   - Excludes ABC, Protocol, and decorated classes (legitimate patterns)

{thailint-0.15.2 → thailint-0.15.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: thailint
-Version: 0.15.2
+Version: 0.15.3
 Summary: The AI Linter - Enterprise-grade linting and governance for AI-generated code across multiple languages
 License: MIT
 License-File: LICENSE

{thailint-0.15.2 → thailint-0.15.3}/pyproject.toml

@@ -17,7 +17,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "thailint"
-version = "0.15.2"
+version = "0.15.3"
 description = "The AI Linter - Enterprise-grade linting and governance for AI-generated code across multiple languages"
 authors = ["Steve Jackson"]
 license = "MIT"

{thailint-0.15.2 → thailint-0.15.3}/src/linters/dry/linter.py

@@ -21,7 +21,9 @@ Interfaces: DRYRule.check(context) -> list[Violation], finalize() -> list[Violat
 Implementation: Delegates all logic to helper classes, maintains only orchestration and state
 
 Suppressions:
-    - too-many-instance-attributes: DRYComponents groups related helper dependencies
+    - too-many-instance-attributes: DRYComponents groups helper dependencies; DRYRule has 8
+        attributes due to stateful caching requirements (storage, config, constants, file contents
+        for ignore directive processing)
     - B101: Type narrowing assertions after guards (storage initialized, file_path/content set)
 """
 
@@ -34,6 +36,7 @@ from pathlib import Path
 from src.core.base import BaseLintContext, BaseLintRule
 from src.core.linter_utils import should_process_file
 from src.core.types import Violation
+from src.linter_config.ignore import IgnoreDirectiveParser
 
 from .config import DRYConfig
 from .config_loader import ConfigLoader
@@ -46,7 +49,7 @@ from .inline_ignore import InlineIgnoreParser
 from .python_constant_extractor import extract_python_constants
 from .storage_initializer import StorageInitializer
 from .typescript_constant_extractor import TypeScriptConstantExtractor
-from .violation_generator import ViolationGenerator
+from .violation_generator import IgnoreContext, ViolationGenerator
 
 
 @dataclass
@@ -62,7 +65,7 @@ class DRYComponents:  # pylint: disable=too-many-instance-attributes
     constant_violation_builder: ConstantViolationBuilder
 
 
-class DRYRule(BaseLintRule):
+class DRYRule(BaseLintRule):  # pylint: disable=too-many-instance-attributes
     """Detects duplicate code across project files."""
 
     def __init__(self) -> None:
@@ -71,10 +74,14 @@ class DRYRule(BaseLintRule):
         self._initialized = False
         self._config: DRYConfig | None = None
         self._file_analyzer: FileAnalyzer | None = None
+        self._project_root: Path | None = None
 
         # Collected constants for cross-file detection: list of (file_path, ConstantInfo)
         self._constants: list[tuple[Path, ConstantInfo]] = []
 
+        # Cache file contents for ignore directive checking during finalize
+        self._file_contents: dict[str, str] = {}
+
         # Helper components grouped to reduce instance attributes
         self._helpers = DRYComponents(
             config_loader=ConfigLoader(),
@@ -133,6 +140,12 @@ class DRYRule(BaseLintRule):
         assert context.file_content is not None  # nosec B101
 
         file_path = context.file_path
+        # Cache file content for ignore directive checking in finalize
+        self._file_contents[str(file_path)] = context.file_content
+        # Get project root from context metadata if available
+        if self._project_root is None:
+            self._project_root = self._get_project_root(context)
+
         self._helpers.inline_ignore.parse_file(file_path, context.file_content)
         self._ensure_storage_initialized(context, config)
         self._analyze_and_store(context, config)
@@ -182,21 +195,56 @@ class DRYRule(BaseLintRule):
         if extract_fn:
             self._constants.extend((file_path, c) for c in extract_fn(context.file_content))
 
+    def _get_project_root(self, context: BaseLintContext) -> Path | None:
+        """Get project root from context if available.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            Project root path or None if not available
+        """
+        # Try to get from metadata (orchestrator sets this)
+        if hasattr(context, "metadata") and isinstance(context.metadata, dict):
+            project_root = context.metadata.get("project_root")
+            if project_root:
+                return Path(project_root)
+
+        # Fallback: derive from file path
+        if context.file_path:
+            return Path(context.file_path).parent
+
+        return None
+
     def finalize(self) -> list[Violation]:
         """Generate violations after all files processed."""
         if not self._storage or not self._config:
             return []
+
+        # Create ignore context for violation filtering
+        ignore_parser = IgnoreDirectiveParser(self._project_root)
+        ignore_ctx = IgnoreContext(
+            inline_ignore=self._helpers.inline_ignore,
+            shared_parser=ignore_parser,
+            file_contents=self._file_contents,
+        )
+
         violations = self._helpers.violation_generator.generate_violations(
-            self._storage, self.rule_id, self._config, self._helpers.inline_ignore
+            self._storage, self.rule_id, self._config, ignore_ctx
         )
         if self._config.detect_duplicate_constants and self._constants:
-            violations.extend(
-                _generate_constant_violations(
-                    self._constants, self._config, self._helpers, self.rule_id
-                )
+            constant_violations = _generate_constant_violations(
+                self._constants, self._config, self._helpers, self.rule_id
             )
+            # Filter constant violations through shared ignore parser
+            constant_violations = _filter_ignored_violations(
+                constant_violations, ignore_parser, self._file_contents
+            )
+            violations.extend(constant_violations)
+
         self._helpers.inline_ignore.clear()
         self._constants = []
+        self._file_contents = {}
         return violations
 
 
@@ -225,3 +273,26 @@ def _generate_constant_violations(
     groups = find_constant_groups(constants)
     helpers.constant_violation_builder.min_occurrences = config.min_constant_occurrences
     return helpers.constant_violation_builder.build_violations(groups, rule_id)
+
+
+def _filter_ignored_violations(
+    violations: list[Violation],
+    ignore_parser: IgnoreDirectiveParser,
+    file_contents: dict[str, str],
+) -> list[Violation]:
+    """Filter violations through the shared ignore directive parser.
+
+    Args:
+        violations: List of violations to filter
+        ignore_parser: Shared ignore directive parser
+        file_contents: Cached file contents for checking ignore directives
+
+    Returns:
+        Filtered list of violations not matching ignore directives
+    """
+    filtered = []
+    for violation in violations:
+        file_content = file_contents.get(violation.file_path, "")
+        if not ignore_parser.should_ignore_violation(violation, file_content):
+            filtered.append(violation)
+    return filtered

{thailint-0.15.2 → thailint-0.15.3}/src/linters/dry/violation_generator.py

@@ -10,14 +10,16 @@ Overview: Handles violation generation for duplicate code blocks. Queries storag
 
 Dependencies: DuplicateStorage, ViolationDeduplicator, DRYViolationBuilder, Violation, DRYConfig
 
-Exports: ViolationGenerator class
+Exports: ViolationGenerator class, IgnoreContext dataclass
 
 Interfaces: ViolationGenerator.generate_violations(storage, rule_id, config) -> list[Violation]
 
 Implementation: Queries storage, deduplicates blocks, builds violations, filters by ignore patterns
 """
 
+from dataclasses import dataclass
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from src.core.types import Violation
 from src.orchestrator.language_detector import detect_language
@@ -28,6 +30,18 @@ from .duplicate_storage import DuplicateStorage
 from .inline_ignore import InlineIgnoreParser
 from .violation_builder import DRYViolationBuilder
 
+if TYPE_CHECKING:
+    from src.linter_config.ignore import IgnoreDirectiveParser
+
+
+@dataclass
+class IgnoreContext:
+    """Context for ignore directive filtering."""
+
+    inline_ignore: InlineIgnoreParser
+    shared_parser: "IgnoreDirectiveParser | None" = None
+    file_contents: dict[str, str] | None = None
+
 
 class ViolationGenerator:
     """Generates violations from duplicate code blocks."""
@@ -42,7 +56,7 @@ class ViolationGenerator:
         storage: DuplicateStorage,
         rule_id: str,
         config: DRYConfig,
-        inline_ignore: InlineIgnoreParser,
+        ignore_ctx: IgnoreContext,
     ) -> list[Violation]:
         """Generate violations from storage.
 
@@ -50,19 +64,42 @@ class ViolationGenerator:
             storage: Duplicate storage instance
             rule_id: Rule identifier for violations
             config: DRY configuration with ignore patterns
-            inline_ignore: Parser with inline ignore directives
+            ignore_ctx: Context containing ignore parsers and file contents
 
         Returns:
             List of violations filtered by ignore patterns and inline directives
         """
-        duplicate_hashes = storage.duplicate_hashes
-        violations = []
+        raw_violations = self._collect_violations(storage, rule_id, config)
+        deduplicated = self._deduplicator.deduplicate_violations(raw_violations)
+        pattern_filtered = self._filter_ignored(deduplicated, config.ignore_patterns)
+        inline_filtered = self._filter_inline_ignored(pattern_filtered, ignore_ctx.inline_ignore)
+
+        # Apply shared ignore directive filtering for block and line directives
+        if ignore_ctx.shared_parser and ignore_ctx.file_contents:
+            return self._filter_shared_ignored(
+                inline_filtered, ignore_ctx.shared_parser, ignore_ctx.file_contents
+            )
+
+        return inline_filtered
 
-        for hash_value in duplicate_hashes:
+    def _collect_violations(
+        self, storage: DuplicateStorage, rule_id: str, config: DRYConfig
+    ) -> list[Violation]:
+        """Collect raw violations from storage duplicate hashes.
+
+        Args:
+            storage: Duplicate storage instance
+            rule_id: Rule identifier for violations
+            config: DRY configuration
+
+        Returns:
+            List of raw violations before filtering
+        """
+        violations = []
+        for hash_value in storage.duplicate_hashes:
             blocks = storage.get_blocks_for_hash(hash_value)
             dedup_blocks = self._deduplicator.deduplicate_blocks(blocks)
 
-            # Check min_occurrences threshold (language-aware)
             if not self._meets_min_occurrences(dedup_blocks, config):
                 continue
 
@@ -70,9 +107,7 @@ class ViolationGenerator:
                 violation = self._violation_builder.build_violation(block, dedup_blocks, rule_id)
                 violations.append(violation)
 
-        deduplicated = self._deduplicator.deduplicate_violations(violations)
-        pattern_filtered = self._filter_ignored(deduplicated, config.ignore_patterns)
-        return self._filter_inline_ignored(pattern_filtered, inline_ignore)
+        return violations
 
     def _meets_min_occurrences(self, blocks: list, config: DRYConfig) -> bool:
         """Check if blocks meet minimum occurrence threshold for the language.
@@ -169,3 +204,28 @@ class ViolationGenerator:
             return int(message[start:end])
         except (ValueError, IndexError):
             return 1
+
+    def _filter_shared_ignored(
+        self,
+        violations: list[Violation],
+        ignore_parser: "IgnoreDirectiveParser",
+        file_contents: dict[str, str],
+    ) -> list[Violation]:
+        """Filter violations using the shared ignore directive parser.
+
+        This enables standard # thailint: ignore-start/end directives for DRY linter.
+
+        Args:
+            violations: List of violations to filter
+            ignore_parser: Shared ignore directive parser
+            file_contents: Cached file contents for ignore checking
+
+        Returns:
+            Filtered list of violations
+        """
+        filtered = []
+        for violation in violations:
+            file_content = file_contents.get(violation.file_path, "")
+            if not ignore_parser.should_ignore_violation(violation, file_content):
+                filtered.append(violation)
+        return filtered

{thailint-0.15.2 → thailint-0.15.3}/src/linters/lazy_ignores/config.py

@@ -42,6 +42,10 @@ class LazyIgnoresConfig:  # pylint: disable=too-many-instance-attributes
     # Orphaned detection
     check_orphaned: bool = True  # Header entries without matching ignores
 
+    # Inline justification options
+    allow_inline_justifications: bool = True  # Allow " - reason" syntax
+    min_justification_length: int = 10  # Minimum chars for valid justification
+
     # File patterns to ignore
     ignore_patterns: list[str] = field(
         default_factory=lambda: [
@@ -64,5 +68,7 @@ class LazyIgnoresConfig:  # pylint: disable=too-many-instance-attributes
             check_thailint_ignore=config_dict.get("check_thailint_ignore", True),
             check_test_skips=config_dict.get("check_test_skips", True),
             check_orphaned=config_dict.get("check_orphaned", True),
+            allow_inline_justifications=config_dict.get("allow_inline_justifications", True),
+            min_justification_length=config_dict.get("min_justification_length", 10),
             ignore_patterns=config_dict.get("ignore_patterns", []),
         )

{thailint-0.15.2 → thailint-0.15.3}/src/linters/lazy_ignores/directive_utils.py

@@ -5,15 +5,21 @@ Scope: Common directive creation and path normalization for ignore detectors
 
 Overview: Provides shared utility functions used across Python, TypeScript, and test skip
     detectors. Centralizes logic for normalizing file paths, extracting rule IDs from
-    regex matches, and creating IgnoreDirective objects to avoid code duplication.
+    regex matches, extracting inline justifications, and creating IgnoreDirective objects
+    to avoid code duplication.
 
 Dependencies: re for match handling, pathlib for file paths, types module for dataclasses
 
-Exports: normalize_path, extract_rule_ids, create_directive, create_directive_no_rules
+Exports: normalize_path, extract_rule_ids, create_directive, create_directive_no_rules,
+    extract_inline_justification
 
 Interfaces: Pure utility functions with no state
 
 Implementation: Simple helper functions for directive creation
+
+Suppressions:
+    too-many-arguments: create_directive needs all params for proper IgnoreDirective construction
+    too-many-positional-arguments: Factory function mirrors IgnoreDirective fields
 """
 
 import re
@@ -21,6 +27,9 @@ from pathlib import Path
 
 from src.linters.lazy_ignores.types import IgnoreDirective, IgnoreType
 
+# Pattern for inline justification: space-dash-space followed by text
+INLINE_JUSTIFICATION_PATTERN = re.compile(r"\s+-\s+(.+)$")
+
 
 def normalize_path(file_path: Path | str | None) -> Path:
     """Normalize file path to Path object.
@@ -38,6 +47,29 @@ def normalize_path(file_path: Path | str | None) -> Path:
     return file_path
 
 
+def extract_inline_justification(raw_text: str) -> str | None:
+    """Extract inline justification from raw directive text.
+
+    Looks for the pattern " - " (space-dash-space) followed by justification text.
+    This allows inline justifications like:
+        # noqa: PLR0912 - state machine inherently complex
+        # type: ignore[arg-type] - library has typing bug
+
+    Args:
+        raw_text: The raw comment text containing the ignore directive
+
+    Returns:
+        The justification text if found, None otherwise.
+        Returns None for empty/whitespace-only justifications.
+    """
+    match = INLINE_JUSTIFICATION_PATTERN.search(raw_text)
+    if not match:
+        return None
+
+    justification = match.group(1).strip()
+    return justification if justification else None
+
+
 def _get_captured_group(match: re.Match[str]) -> str | None:
     """Get the first captured group from a regex match if it exists.
 
@@ -69,12 +101,13 @@ def extract_rule_ids(match: re.Match[str]) -> list[str]:
     return [rule_id for rule_id in ids if rule_id]
 
 
-def create_directive(
+def create_directive(  # pylint: disable=too-many-arguments,too-many-positional-arguments
     match: re.Match[str],
     ignore_type: IgnoreType,
     line_num: int,
     file_path: Path,
     rule_ids: tuple[str, ...] | None = None,
+    full_line: str | None = None,
 ) -> IgnoreDirective:
     """Create an IgnoreDirective from a regex match.
 
@@ -84,6 +117,7 @@ def create_directive(
         line_num: 1-indexed line number
         file_path: Path to source file
         rule_ids: Optional tuple of rule IDs; if None, extracts from match group 1
+        full_line: Optional full line text for extracting inline justification
 
     Returns:
         IgnoreDirective for this match
@@ -91,13 +125,22 @@ def create_directive(
     if rule_ids is None:
         rule_ids = tuple(extract_rule_ids(match))
 
+    # Use full line from match position to capture inline justification
+    if full_line is not None:
+        raw_text = full_line[match.start() :].strip()
+    else:
+        raw_text = match.group(0).strip()
+
+    inline_justification = extract_inline_justification(raw_text)
+
     return IgnoreDirective(
         ignore_type=ignore_type,
         rule_ids=rule_ids,
         line=line_num,
         column=match.start() + 1,
-        raw_text=match.group(0).strip(),
+        raw_text=raw_text,
         file_path=file_path,
+        inline_justification=inline_justification,
     )
 
 

{thailint-0.15.2 → thailint-0.15.3}/src/linters/lazy_ignores/matcher.py

@@ -32,13 +32,15 @@ from .types import IgnoreDirective, IgnoreType
 class IgnoreSuppressionMatcher:
     """Matches ignore directives with header suppressions."""
 
-    def __init__(self, parser: SuppressionsParser) -> None:
+    def __init__(self, parser: SuppressionsParser, min_justification_length: int = 10) -> None:
         """Initialize the matcher.
 
         Args:
             parser: SuppressionsParser for rule ID normalization.
+            min_justification_length: Minimum length for valid inline justification.
         """
         self._parser = parser
+        self._min_justification_length = min_justification_length
 
     def collect_used_rule_ids(self, ignores: list[IgnoreDirective]) -> set[str]:
         """Collect all normalized rule IDs used in ignore directives.
@@ -72,6 +74,9 @@ class IgnoreSuppressionMatcher:
     ) -> list[str]:
         """Find which rule IDs in an ignore are not justified.
 
+        Checks inline justification first (higher precedence), then falls back
+        to header-based suppressions.
+
         Args:
             ignore: The ignore directive to check.
             suppressions: Dict of normalized rule IDs to justifications.
@@ -79,17 +84,45 @@ class IgnoreSuppressionMatcher:
         Returns:
             List of unjustified rule IDs (original case preserved).
         """
+        if self._has_valid_inline_justification(ignore):
+            return []
+
         if not ignore.rule_ids:
-            type_key = self._normalize(ignore.ignore_type.value)
-            if type_key not in suppressions:
-                return [ignore.ignore_type.value]
+            return self._check_bare_ignore(ignore, suppressions)
+
+        return self._check_rule_specific_ignore(ignore, suppressions)
+
+    def _check_bare_ignore(
+        self, ignore: IgnoreDirective, suppressions: dict[str, str]
+    ) -> list[str]:
+        """Check if a bare ignore (no specific rules) is justified."""
+        type_key = self._normalize(ignore.ignore_type.value)
+        if type_key in suppressions:
             return []
+        return [ignore.ignore_type.value]
 
-        unjustified: list[str] = []
-        for rule_id in ignore.rule_ids:
-            if not self._is_rule_justified(ignore, rule_id, suppressions):
-                unjustified.append(rule_id)
-        return unjustified
+    def _check_rule_specific_ignore(
+        self, ignore: IgnoreDirective, suppressions: dict[str, str]
+    ) -> list[str]:
+        """Check which specific rule IDs are not justified."""
+        return [
+            rule_id
+            for rule_id in ignore.rule_ids
+            if not self._is_rule_justified(ignore, rule_id, suppressions)
+        ]
+
+    def _has_valid_inline_justification(self, ignore: IgnoreDirective) -> bool:
+        """Check if the ignore has a valid inline justification.
+
+        Args:
+            ignore: The ignore directive to check.
+
+        Returns:
+            True if the ignore has an inline justification meeting minimum length.
+        """
+        if not ignore.inline_justification:
+            return False
+        return len(ignore.inline_justification) >= self._min_justification_length
 
     def _is_rule_justified(
         self, ignore: IgnoreDirective, rule_id: str, suppressions: dict[str, str]

{thailint-0.15.2 → thailint-0.15.3}/src/linters/lazy_ignores/python_analyzer.py

@@ -205,5 +205,5 @@ class PythonIgnoreDetector:
                 continue
             if _is_pattern_in_string_literal(line, match.start()):
                 continue
-            found.append(create_directive(match, ignore_type, line_num, file_path))
+            found.append(create_directive(match, ignore_type, line_num, file_path, full_line=line))
         return found

{thailint-0.15.2 → thailint-0.15.3}/src/linters/lazy_ignores/types.py

@@ -59,6 +59,7 @@ class IgnoreDirective:
     column: int
     raw_text: str  # Original comment text
     file_path: Path
+    inline_justification: str | None = None  # Justification after " - " delimiter
 
 
 @dataclass(frozen=True)

{thailint-0.15.2 → thailint-0.15.3}/src/linters/lazy_ignores/violation_builder.py

@@ -72,8 +72,12 @@ def _build_unjustified_suggestion(rule_id: str) -> str:
 
     suppression_entries = "\n".join(f"    {rid}: [Your justification here]" for rid in rule_ids)
 
-    return f"""To fix, add an entry to the file header Suppressions section:
+    return f"""To fix, either:
 
+1. Add an inline justification (10+ chars) after the ignore directive:
+   # noqa: {rule_ids[0]} - [Your justification here]
+
+2. Or add an entry to the file header Suppressions section:
     Suppressions:
 {suppression_entries}
 

{thailint-0.15.2 → thailint-0.15.3}/src/linters/stringly_typed/storage.py

@@ -461,7 +461,7 @@ class StringlyTypedStorage:  # thailint: ignore[srp]
             List of (function_name, param_index, unique_values) tuples
         """
         cursor = self._db.execute(
-            """SELECT function_name, param_index, GROUP_CONCAT(DISTINCT string_value)
+            """SELECT function_name, param_index, json_group_array(DISTINCT string_value)
                FROM function_calls
                GROUP BY function_name, param_index
                HAVING COUNT(DISTINCT string_value) >= ?
@@ -470,12 +470,7 @@ class StringlyTypedStorage:  # thailint: ignore[srp]
             (min_values, max_values, min_files),
         )
 
-        results: list[tuple[str, int, set[str]]] = []
-        for row in cursor.fetchall():
-            values = set(row[2].split(",")) if row[2] else set()
-            results.append((row[0], row[1], values))
-
-        return results
+        return [(row[0], row[1], set(json.loads(row[2]))) for row in cursor.fetchall()]
 
     def get_calls_by_function(
         self, function_name: str, param_index: int
@@ -566,7 +561,7 @@ class StringlyTypedStorage:  # thailint: ignore[srp]
             List of (variable_name, unique_values) tuples
         """
         cursor = self._db.execute(
-            """SELECT variable_name, GROUP_CONCAT(DISTINCT compared_value)
+            """SELECT variable_name, json_group_array(DISTINCT compared_value)
                FROM string_comparisons
                GROUP BY variable_name
                HAVING COUNT(DISTINCT compared_value) >= ?
@@ -574,12 +569,7 @@ class StringlyTypedStorage:  # thailint: ignore[srp]
             (min_values, min_files),
         )
 
-        results: list[tuple[str, set[str]]] = []
-        for row in cursor.fetchall():
-            values = set(row[1].split(",")) if row[1] else set()
-            results.append((row[0], values))
-
-        return results
+        return [(row[0], set(json.loads(row[1]))) for row in cursor.fetchall()]
 
     def get_comparisons_by_variable(self, variable_name: str) -> list[StoredComparison]:
         """Get all comparisons for a specific variable.