thailint 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

src/linters/file_placement/pattern_matcher.py

@@ -23,6 +23,10 @@ import re
 class PatternMatcher:
     """Handles regex pattern matching for file paths."""
 
+    def __init__(self) -> None:
+        """Initialize the pattern matcher."""
+        pass  # Stateless matcher for regex patterns
+
     def match_deny_patterns(
         self, path_str: str, deny_patterns: list[dict[str, str]]
     ) -> tuple[bool, str | None]:

src/linters/file_placement/pattern_validator.py

@@ -24,6 +24,10 @@ from typing import Any
 class PatternValidator:
     """Validates regex patterns in file placement configuration."""
 
+    def __init__(self) -> None:
+        """Initialize the pattern validator."""
+        pass  # Stateless validator for regex patterns
+
     def validate_config(self, config: dict[str, Any]) -> None:
         """Validate all regex patterns in configuration.
 

src/linters/magic_numbers/context_analyzer.py

@@ -30,6 +30,10 @@ from pathlib import Path
 class ContextAnalyzer:  # thailint: ignore[srp]
     """Analyzes contexts to determine if numeric literals are acceptable."""
 
+    def __init__(self) -> None:
+        """Initialize the context analyzer."""
+        pass  # Stateless analyzer for context checking
+
     def is_acceptable_context(
         self,
         node: ast.Constant,

src/linters/magic_numbers/typescript_analyzer.py

@@ -44,6 +44,10 @@ class TypeScriptMagicNumberAnalyzer(TypeScriptBaseAnalyzer):  # thailint: ignore
     of TypeScript magic number detection - all methods support this core purpose.
     """
 
+    def __init__(self) -> None:  # pylint: disable=useless-parent-delegation
+        """Initialize the TypeScript magic number analyzer."""
+        super().__init__()  # Sets self.tree_sitter_available from base class
+
     def find_numeric_literals(self, root_node: Node) -> list[tuple[Node, float | int, int]]:
         """Find all numeric literal nodes in TypeScript/JavaScript AST.
 

src/linters/nesting/python_analyzer.py

@@ -25,6 +25,10 @@ import ast
 class PythonNestingAnalyzer:
     """Calculates maximum nesting depth in Python functions."""
 
+    def __init__(self) -> None:
+        """Initialize the Python nesting analyzer."""
+        pass  # Stateless analyzer for nesting depth calculation
+
     def calculate_max_depth(
         self, func_node: ast.FunctionDef | ast.AsyncFunctionDef
     ) -> tuple[int, int]:

src/linters/nesting/typescript_function_extractor.py

@@ -27,6 +27,10 @@ from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
 class TypeScriptFunctionExtractor(TypeScriptBaseAnalyzer):
     """Extracts function information from TypeScript AST nodes."""
 
+    def __init__(self) -> None:  # pylint: disable=useless-parent-delegation
+        """Initialize the TypeScript function extractor."""
+        super().__init__()  # Sets self.tree_sitter_available from base class
+
     def collect_all_functions(self, root_node: Any) -> list[tuple[Any, str]]:
         """Collect all function nodes from TypeScript AST.
 

src/linters/print_statements/typescript_analyzer.py

@@ -40,6 +40,10 @@ except ImportError:
 class TypeScriptPrintStatementAnalyzer(TypeScriptBaseAnalyzer):
     """Analyzes TypeScript/JavaScript code for console.* calls using Tree-sitter."""
 
+    def __init__(self) -> None:  # pylint: disable=useless-parent-delegation
+        """Initialize the TypeScript print statement analyzer."""
+        super().__init__()  # Sets self.tree_sitter_available from base class
+
     def find_console_calls(self, root_node: Node, methods: set[str]) -> list[tuple[Node, str, int]]:
         """Find all console.* calls matching the specified methods.
 

src/linters/srp/class_analyzer.py

@@ -31,6 +31,10 @@ from .typescript_analyzer import TypeScriptSRPAnalyzer
 class ClassAnalyzer:
     """Coordinates class analysis for Python and TypeScript."""
 
+    def __init__(self) -> None:
+        """Initialize the class analyzer."""
+        pass  # Coordinates analysis between language-specific analyzers
+
     def analyze_python(
         self, context: BaseLintContext, config: SRPConfig
     ) -> list[dict[str, Any]] | list[Violation]:

src/linters/srp/python_analyzer.py

@@ -1,7 +1,7 @@
 """
 Purpose: Python AST analyzer for detecting SRP violations in Python classes
 
-Scope: PythonSRPAnalyzer class for analyzing Python classes using AST
+Scope: Functions for analyzing Python classes using AST
 
 Overview: Implements Python-specific SRP analysis using the ast module to parse and analyze
     class definitions. Walks the AST to find all class definitions, then analyzes each class
@@ -13,7 +13,7 @@ Overview: Implements Python-specific SRP analysis using the ast module to parse
 
 Dependencies: ast module for Python AST parsing, typing for type hints, heuristics module
 
-Exports: PythonSRPAnalyzer class
+Exports: find_all_classes function, analyze_class function, PythonSRPAnalyzer class (compat)
 
 Interfaces: find_all_classes(tree), analyze_class(class_node, source, config)
 
@@ -27,8 +27,58 @@ from .config import SRPConfig
 from .heuristics import count_loc, count_methods, has_responsibility_keyword
 
 
+def find_all_classes(tree: ast.AST) -> list[ast.ClassDef]:
+    """Find all class definitions in AST.
+
+    Args:
+        tree: Root AST node to search
+
+    Returns:
+        List of all class definition nodes
+    """
+    classes = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            classes.append(node)
+    return classes
+
+
+def analyze_class(class_node: ast.ClassDef, source: str, config: SRPConfig) -> dict[str, Any]:
+    """Analyze a class for SRP metrics.
+
+    Args:
+        class_node: AST node representing a class definition
+        source: Full source code of the file
+        config: SRP configuration with thresholds and keywords
+
+    Returns:
+        Dictionary with class metrics (name, method_count, loc, etc.)
+    """
+    method_count = count_methods(class_node)
+    loc = count_loc(class_node, source)
+    has_keyword = has_responsibility_keyword(class_node.name, config.keywords)
+
+    return {
+        "class_name": class_node.name,
+        "method_count": method_count,
+        "loc": loc,
+        "has_keyword": has_keyword,
+        "line": class_node.lineno,
+        "column": class_node.col_offset,
+    }
+
+
+# Legacy class wrapper for backward compatibility
 class PythonSRPAnalyzer:
-    """Analyzes Python classes for SRP violations."""
+    """Analyzes Python classes for SRP violations.
+
+    Note: This class is a thin wrapper around module-level functions
+    for backward compatibility.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the analyzer."""
+        pass  # No state needed
 
     def find_all_classes(self, tree: ast.AST) -> list[ast.ClassDef]:
         """Find all class definitions in AST.
@@ -39,11 +89,7 @@ class PythonSRPAnalyzer:
         Returns:
             List of all class definition nodes
         """
-        classes = []
-        for node in ast.walk(tree):
-            if isinstance(node, ast.ClassDef):
-                classes.append(node)
-        return classes
+        return find_all_classes(tree)
 
     def analyze_class(
         self, class_node: ast.ClassDef, source: str, config: SRPConfig
@@ -58,15 +104,4 @@ class PythonSRPAnalyzer:
         Returns:
             Dictionary with class metrics (name, method_count, loc, etc.)
         """
-        method_count = count_methods(class_node)
-        loc = count_loc(class_node, source)
-        has_keyword = has_responsibility_keyword(class_node.name, config.keywords)
-
-        return {
-            "class_name": class_node.name,
-            "method_count": method_count,
-            "loc": loc,
-            "has_keyword": has_keyword,
-            "line": class_node.lineno,
-            "column": class_node.col_offset,
-        }
+        return analyze_class(class_node, source, config)

src/linters/srp/typescript_metrics_calculator.py

@@ -10,7 +10,7 @@ Overview: Provides metrics calculation functionality for TypeScript classes in S
 
 Dependencies: typing
 
-Exports: TypeScriptMetricsCalculator
+Exports: count_methods function, count_loc function, TypeScriptMetricsCalculator class (compat)
 
 Interfaces: count_methods(class_node), count_loc(class_node, source)
 
@@ -20,8 +20,87 @@ Implementation: Tree-sitter node type matching, AST position arithmetic
 from typing import Any
 
 
+def count_methods(class_node: Any) -> int:
+    """Count number of methods in a TypeScript class.
+
+    Args:
+        class_node: Class declaration tree-sitter node
+
+    Returns:
+        Number of public methods (excludes constructor)
+    """
+    class_body = _get_class_body(class_node)
+    if not class_body:
+        return 0
+
+    method_count = 0
+    for child in class_body.children:
+        if _is_countable_method(child):
+            method_count += 1
+
+    return method_count
+
+
+def count_loc(class_node: Any, source: str) -> int:
+    """Count lines of code in a TypeScript class.
+
+    Args:
+        class_node: Class declaration tree-sitter node
+        source: Full source code string
+
+    Returns:
+        Number of lines in class definition
+    """
+    start_line = class_node.start_point[0]
+    end_line = class_node.end_point[0]
+    return end_line - start_line + 1
+
+
+def _get_class_body(class_node: Any) -> Any:
+    """Get the class_body node from a class declaration.
+
+    Args:
+        class_node: Class declaration node
+
+    Returns:
+        Class body node or None
+    """
+    for child in class_node.children:
+        if child.type == "class_body":
+            return child
+    return None
+
+
+def _is_countable_method(node: Any) -> bool:
+    """Check if node is a method that should be counted.
+
+    Args:
+        node: Tree-sitter node to check
+
+    Returns:
+        True if node is a countable method
+    """
+    if node.type != "method_definition":
+        return False
+
+    # Check if it's a constructor
+    return all(
+        not (child.type == "property_identifier" and child.text.decode() == "constructor")
+        for child in node.children
+    )
+
+
+# Legacy class wrapper for backward compatibility
 class TypeScriptMetricsCalculator:
-    """Calculates metrics for TypeScript classes."""
+    """Calculates metrics for TypeScript classes.
+
+    Note: This class is a thin wrapper around module-level functions
+    for backward compatibility.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the metrics calculator."""
+        pass  # No state needed
 
     def count_methods(self, class_node: Any) -> int:
         """Count number of methods in a TypeScript class.
@@ -32,16 +111,7 @@ class TypeScriptMetricsCalculator:
         Returns:
             Number of public methods (excludes constructor)
         """
-        class_body = self._get_class_body(class_node)
-        if not class_body:
-            return 0
-
-        method_count = 0
-        for child in class_body.children:
-            if self._is_countable_method(child):
-                method_count += 1
-
-        return method_count
+        return count_methods(class_node)
 
     def count_loc(self, class_node: Any, source: str) -> int:
         """Count lines of code in a TypeScript class.
@@ -53,38 +123,4 @@ class TypeScriptMetricsCalculator:
         Returns:
             Number of lines in class definition
         """
-        start_line = class_node.start_point[0]
-        end_line = class_node.end_point[0]
-        return end_line - start_line + 1
-
-    def _get_class_body(self, class_node: Any) -> Any:
-        """Get the class_body node from a class declaration.
-
-        Args:
-            class_node: Class declaration node
-
-        Returns:
-            Class body node or None
-        """
-        for child in class_node.children:
-            if child.type == "class_body":
-                return child
-        return None
-
-    def _is_countable_method(self, node: Any) -> bool:
-        """Check if node is a method that should be counted.
-
-        Args:
-            node: Tree-sitter node to check
-
-        Returns:
-            True if node is a countable method
-        """
-        if node.type != "method_definition":
-            return False
-
-        # Check if it's a constructor
-        return all(
-            not (child.type == "property_identifier" and child.text.decode() == "constructor")
-            for child in node.children
-        )
+        return count_loc(class_node, source)

src/linters/srp/violation_builder.py

@@ -29,6 +29,10 @@ from src.core.violation_builder import BaseViolationBuilder, ViolationInfo
 class ViolationBuilder(BaseViolationBuilder):
     """Builds SRP violations with messages and suggestions."""
 
+    def __init__(self) -> None:  # pylint: disable=useless-parent-delegation
+        """Initialize the violation builder."""
+        super().__init__()  # Inherits from BaseViolationBuilder
+
     def build_violation(
         self,
         metrics: dict[str, Any],

src/linters/stateless_class/__init__.py

@@ -0,0 +1,25 @@
+"""
+Purpose: Stateless class linter package for detecting classes without state
+
+Scope: Python classes that should be refactored to module-level functions
+
+Overview: Package for detecting Python classes that have no constructor (__init__
+    or __new__) and no instance state (self.attr assignments), indicating they should
+    be refactored to module-level functions. Identifies a common anti-pattern in
+    AI-generated code where classes are used as namespaces rather than for object-
+    oriented encapsulation.
+
+Dependencies: Python AST module, base linter framework
+
+Exports: StatelessClassRule - main rule for detecting stateless classes
+
+Interfaces: StatelessClassRule.check(context) -> list[Violation]
+
+Implementation: AST-based analysis checking for constructor methods and instance
+    attribute assignments while excluding legitimate patterns (ABC, Protocol, decorators)
+"""
+
+from .linter import StatelessClassRule
+from .python_analyzer import ClassInfo, StatelessClassAnalyzer
+
+__all__ = ["StatelessClassRule", "StatelessClassAnalyzer", "ClassInfo"]

src/linters/stateless_class/config.py

@@ -0,0 +1,58 @@
+"""
+Purpose: Configuration schema for stateless-class linter
+
+Scope: Stateless class linter configuration for Python files
+
+Overview: Defines configuration schema for stateless-class linter. Provides
+    StatelessClassConfig dataclass with enabled flag, min_methods threshold (default 2)
+    for determining minimum methods required to flag a class as stateless, and ignore
+    patterns list for excluding specific files or directories. Supports per-file and
+    per-directory config overrides through from_dict class method. Integrates with
+    orchestrator's configuration system via .thailint.yaml.
+
+Dependencies: dataclasses module for configuration structure, typing module for type hints
+
+Exports: StatelessClassConfig dataclass
+
+Interfaces: from_dict(config, language) -> StatelessClassConfig for configuration loading
+
+Implementation: Dataclass with defaults matching stateless class detection conventions
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class StatelessClassConfig:
+    """Configuration for stateless-class linter."""
+
+    enabled: bool = True
+    min_methods: int = 2
+    ignore: list[str] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(
+        cls, config: dict[str, Any] | None, language: str | None = None
+    ) -> "StatelessClassConfig":
+        """Load configuration from dictionary.
+
+        Args:
+            config: Dictionary containing configuration values, or None
+            language: Programming language (unused, for interface compatibility)
+
+        Returns:
+            StatelessClassConfig instance with values from dictionary
+        """
+        if config is None:
+            return cls()
+
+        ignore_patterns = config.get("ignore", [])
+        if not isinstance(ignore_patterns, list):
+            ignore_patterns = []
+
+        return cls(
+            enabled=config.get("enabled", True),
+            min_methods=config.get("min_methods", 2),
+            ignore=ignore_patterns,
+        )