thailint 0.1.5__py3-none-any.whl → 0.5.0__py3-none-any.whl

src/__init__.py

@@ -7,13 +7,14 @@ Overview: Initializes the CLI application package, defines version number using
     and exports the public API. Provides single source of truth for version information used by
     setup tools, CLI help text, and documentation. Exports main CLI entry point, high-level Linter
     class for library usage, configuration utilities, and direct linter imports for advanced usage.
-    Includes nesting depth linter exports for convenient access to nesting analysis functionality.
+    Includes nesting depth linter and SRP linter exports for convenient access to code analysis.
     Version is dynamically loaded from package metadata (pyproject.toml) using importlib.metadata.
 
 Dependencies: importlib.metadata for dynamic version loading from installed package metadata
 
 Exports: __version__, Linter (high-level API), cli (CLI entry point), load_config, save_config,
-    ConfigError, Orchestrator (advanced usage), file_placement_lint, nesting_lint, NestingDepthRule
+    ConfigError, Orchestrator (advanced usage), file_placement_lint, nesting_lint, NestingDepthRule,
+    srp_lint, SRPRule
 
 Interfaces: Package version string, Linter class API, CLI command group, configuration functions
 """
@@ -37,6 +38,8 @@ from src.config import ConfigError, load_config, save_config
 from src.linters.file_placement import lint as file_placement_lint
 from src.linters.nesting import NestingDepthRule
 from src.linters.nesting import lint as nesting_lint
+from src.linters.srp import SRPRule
+from src.linters.srp import lint as srp_lint
 from src.orchestrator.core import Orchestrator
 
 __all__ = [
@@ -53,4 +56,6 @@ __all__ = [
     "file_placement_lint",
     "nesting_lint",
     "NestingDepthRule",
+    "srp_lint",
+    "SRPRule",
 ]

src/analyzers/__init__.py

@@ -0,0 +1,23 @@
+"""
+Purpose: Analyzers package for language-specific AST analysis base classes
+
+Scope: Language analyzers (TypeScript, Python) providing shared parsing and traversal utilities
+
+Overview: Package containing base analyzer classes for different programming languages.
+    Provides common tree-sitter initialization, AST parsing, and node traversal patterns
+    to eliminate duplicate code across linters. Each language has a base analyzer class
+    (TypeScriptBaseAnalyzer, etc.) that linter-specific analyzers extend. Centralizes
+    language parsing infrastructure to improve maintainability and consistency.
+
+Dependencies: tree-sitter, language-specific tree-sitter bindings
+
+Exports: TypeScriptBaseAnalyzer
+
+Interfaces: Base analyzer classes with parse(), walk_tree(), and extract() methods
+
+Implementation: Composition-based design for linter analyzers to use base utilities
+"""
+
+from .typescript_base import TypeScriptBaseAnalyzer
+
+__all__ = ["TypeScriptBaseAnalyzer"]

src/analyzers/typescript_base.py

@@ -0,0 +1,148 @@
+"""
+Purpose: Base class for TypeScript AST analysis with tree-sitter parsing
+
+Scope: Common tree-sitter initialization, parsing, and traversal utilities for TypeScript
+
+Overview: Provides shared infrastructure for TypeScript code analysis using tree-sitter parser.
+    Implements common tree-sitter initialization with language setup and parser configuration.
+    Provides reusable parsing methods that convert TypeScript source to AST nodes. Includes
+    shared traversal utilities for walking AST trees recursively and finding nodes by type.
+    Centralizes node extraction patterns including name extraction from identifiers and
+    type identifiers. Serves as foundation for specialized analyzers (SRP, nesting, DRY)
+    to eliminate duplicate tree-sitter boilerplate.
+
+Dependencies: tree-sitter, tree-sitter-typescript
+
+Exports: TypeScriptBaseAnalyzer class with parsing and traversal utilities
+
+Interfaces: parse_typescript(code), walk_tree(node, node_type), extract_node_text(node)
+
+Implementation: Tree-sitter parser singleton, recursive AST traversal, composition pattern
+"""
+
+from typing import Any
+
+try:
+    import tree_sitter_typescript as tstypescript
+    from tree_sitter import Language, Node, Parser
+
+    TS_LANGUAGE = Language(tstypescript.language_typescript())
+    TS_PARSER = Parser(TS_LANGUAGE)
+    TREE_SITTER_AVAILABLE = True
+except ImportError:
+    TREE_SITTER_AVAILABLE = False
+    TS_PARSER = None  # type: ignore[assignment]
+    Node = Any  # type: ignore[assignment,misc]
+
+
+class TypeScriptBaseAnalyzer:
+    """Base analyzer for TypeScript code using tree-sitter."""
+
+    def __init__(self) -> None:
+        """Initialize TypeScript base analyzer."""
+        self.tree_sitter_available = TREE_SITTER_AVAILABLE
+
+    def parse_typescript(self, code: str) -> Node | None:
+        """Parse TypeScript code to AST using tree-sitter.
+
+        Args:
+            code: TypeScript source code to parse
+
+        Returns:
+            Tree-sitter AST root node, or None if parsing fails or tree-sitter unavailable
+        """
+        if not TREE_SITTER_AVAILABLE or TS_PARSER is None:
+            return None
+
+        tree = TS_PARSER.parse(bytes(code, "utf8"))
+        return tree.root_node
+
+    def walk_tree(self, node: Node, node_type: str) -> list[Node]:
+        """Find all nodes of a specific type in the AST.
+
+        Recursively walks the tree and collects all nodes matching the given type.
+
+        Args:
+            node: Root tree-sitter node to search from
+            node_type: Tree-sitter node type to find (e.g., "class_declaration")
+
+        Returns:
+            List of all matching nodes
+        """
+        if not TREE_SITTER_AVAILABLE or node is None:
+            return []
+
+        nodes: list[Node] = []
+        self._walk_tree_recursive(node, node_type, nodes)
+        return nodes
+
+    def _walk_tree_recursive(self, node: Node, node_type: str, nodes: list[Node]) -> None:
+        """Recursively walk tree to find nodes of specific type.
+
+        Args:
+            node: Current tree-sitter node
+            node_type: Node type to find
+            nodes: List to accumulate matching nodes
+        """
+        if node.type == node_type:
+            nodes.append(node)
+
+        for child in node.children:
+            self._walk_tree_recursive(child, node_type, nodes)
+
+    def extract_node_text(self, node: Node) -> str:
+        """Extract text content from a tree-sitter node.
+
+        Args:
+            node: Tree-sitter node
+
+        Returns:
+            Decoded text content of the node
+        """
+        text = node.text
+        if text is None:
+            return ""
+        return text.decode()
+
+    def find_child_by_type(self, node: Node, child_type: str) -> Node | None:
+        """Find first child node of a specific type.
+
+        Args:
+            node: Parent node to search
+            child_type: Child node type to find
+
+        Returns:
+            First matching child node or None
+        """
+        for child in node.children:
+            if child.type == child_type:
+                return child
+        return None
+
+    def find_children_by_types(self, node: Node, child_types: set[str]) -> list[Node]:
+        """Find all children matching any of the given types.
+
+        Args:
+            node: Parent node to search
+            child_types: Set of child node types to find
+
+        Returns:
+            List of matching child nodes
+        """
+        return [child for child in node.children if child.type in child_types]
+
+    def extract_identifier_name(self, node: Node) -> str:
+        """Extract identifier or type_identifier name from node children.
+
+        Common pattern for extracting names from class/function declarations.
+
+        Args:
+            node: Node to extract identifier from
+
+        Returns:
+            Identifier name or default fallback
+        """
+        for child in node.children:
+            if child.type in ("identifier", "type_identifier", "property_identifier"):
+                return self.extract_node_text(child)
+        return "anonymous"

src/api.py

@@ -60,7 +60,7 @@ class Linter:
 
         config_path = self._resolve_config_path(config_file)
         self.config = self.config_loader.load(config_path)
-        self.orchestrator = Orchestrator(project_root=self.project_root)
+        self.orchestrator = Orchestrator(project_root=self.project_root, config=self.config)
 
     def _resolve_config_path(self, config_file: str | Path | None) -> Path:
         """Resolve configuration file path."""