thailint 0.4.3__tar.gz → 0.4.4__tar.gz

{thailint-0.4.3 → thailint-0.4.4}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: thailint
-Version: 0.4.3
+Version: 0.4.4
 Summary: The AI Linter - Enterprise-grade linting and governance for AI-generated code across multiple languages
 License: MIT
+License-File: LICENSE
 Keywords: linter,ai,code-quality,static-analysis,file-placement,governance,multi-language,cli,docker,python
 Author: Steve Jackson
 Requires-Python: >=3.11,<4.0
@@ -15,6 +16,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Quality Assurance

{thailint-0.4.3 → thailint-0.4.4}/pyproject.toml

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

{thailint-0.4.3 → thailint-0.4.4}/src/linters/dry/python_analyzer.py

@@ -62,6 +62,9 @@ class PythonDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.violat
         """
         super().__init__()
         self._filter_registry = filter_registry or create_default_registry()
+        # 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
 
     def analyze(self, file_path: Path, content: str, config: DRYConfig) -> list[CodeBlock]:
         """Analyze Python file for duplicate code blocks, excluding docstrings.
@@ -74,37 +77,46 @@ class PythonDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.violat
         Returns:
             List of CodeBlock instances with hash values
         """
-        # Get docstring line ranges
-        docstring_ranges = self._get_docstring_ranges_from_content(content)
+        # Performance optimization: Parse AST once and cache for _is_single_statement_in_source() calls
+        self._cached_ast = self._parse_content_safe(content)
+        self._cached_content = content
 
-        # Tokenize with line number tracking
-        lines_with_numbers = self._tokenize_with_line_numbers(content, docstring_ranges)
+        try:
+            # Get docstring line ranges
+            docstring_ranges = self._get_docstring_ranges_from_content(content)
 
-        # Generate rolling hash windows
-        windows = self._rolling_hash_with_tracking(lines_with_numbers, config.min_duplicate_lines)
+            # Tokenize with line number tracking
+            lines_with_numbers = self._tokenize_with_line_numbers(content, docstring_ranges)
 
-        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
+            # Generate rolling hash windows
+            windows = self._rolling_hash_with_tracking(lines_with_numbers, config.min_duplicate_lines)
 
-            block = CodeBlock(
-                file_path=file_path,
-                start_line=start_line,
-                end_line=end_line,
-                snippet=snippet,
-                hash_value=hash_val,
-            )
+            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
 
-            # Apply extensible filters (keyword arguments, imports, etc.)
-            if self._filter_registry.should_filter_block(block, content):
-                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)
+                blocks.append(block)
 
-        return blocks
+            return blocks
+        finally:
+            # Clear cache after analysis to avoid memory leaks
+            self._cached_ast = None
+            self._cached_content = None
 
     def _get_docstring_ranges_from_content(self, content: str) -> set[int]:
         """Extract line numbers that are part of docstrings.
@@ -225,10 +237,19 @@ class PythonDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.violat
         return hashes
 
     def _is_single_statement_in_source(self, content: str, start_line: int, end_line: int) -> bool:
-        """Check if a line range in the original source is a single logical statement."""
-        tree = self._parse_content_safe(content)
-        if tree is None:
-            return False
+        """Check if a line range in the original source is a single logical statement.
+
+        Performance optimization: Uses cached AST if available (set by analyze() method)
+        to avoid re-parsing the entire file for each hash window check.
+        """
+        # Use cached AST if available and content matches
+        if self._cached_ast is not None and content == self._cached_content:
+            tree = self._cached_ast
+        else:
+            # Fallback: parse content (used by tests or standalone calls)
+            tree = self._parse_content_safe(content)
+            if tree is None:
+                return False
 
         return self._check_overlapping_nodes(tree, start_line, end_line)
 
@@ -241,9 +262,19 @@ class PythonDuplicateAnalyzer(BaseTokenAnalyzer):  # thailint: ignore[srp.violat
             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."""
+        """Check if any AST node overlaps and matches single-statement pattern.
+
+        Performance optimization: Pre-filter nodes by line range before expensive pattern checks.
+        """
         for node in ast.walk(tree):
-            if self._node_overlaps_and_matches(node, start_line, end_line):
+            # 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
+
+            # Node overlaps - check if it matches single-statement pattern
+            if self._is_single_statement_pattern(node, start_line, end_line):
                 return True
         return False
 

{thailint-0.4.3 → thailint-0.4.4}/src/orchestrator/core.py

@@ -101,8 +101,9 @@ class Orchestrator:
         self.config_loader = LinterConfigLoader()
         self.ignore_parser = IgnoreDirectiveParser(self.project_root)
 
-        # Auto-discover and register all linting rules from src.linters
-        self.registry.discover_rules("src.linters")
+        # Performance optimization: Defer rule discovery until first file is linted
+        # This eliminates ~0.077s overhead for commands that don't need rules (--help, config, etc.)
+        self._rules_discovered = False
 
         # Use provided config or load from project root
         if config is not None:
@@ -208,6 +209,12 @@ class Orchestrator:
 
         return violations
 
+    def _ensure_rules_discovered(self) -> None:
+        """Ensure rules have been discovered and registered (lazy initialization)."""
+        if not self._rules_discovered:
+            self.registry.discover_rules("src.linters")
+            self._rules_discovered = True
+
     def _get_rules_for_file(self, file_path: Path, language: str) -> list[BaseLintRule]:
         """Get rules applicable to this file.
 
@@ -218,6 +225,9 @@ class Orchestrator:
         Returns:
             List of rules to execute against this file.
         """
+        # Lazy initialization: discover rules on first lint operation
+        self._ensure_rules_discovered()
+
         # For now, return all registered rules
         # Future: filter by language, configuration, etc.
         return self.registry.list_all()