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

src/linters/print_statements/typescript_analyzer.py

@@ -0,0 +1,135 @@
+"""
+File: src/linters/print_statements/typescript_analyzer.py
+
+Purpose: TypeScript/JavaScript console.* call detection using Tree-sitter AST analysis
+
+Exports: TypeScriptPrintStatementAnalyzer class
+
+Depends: TypeScriptBaseAnalyzer for tree-sitter parsing, tree-sitter Node type
+
+Implements: find_console_calls(root_node, methods) -> list[tuple]
+
+Related: src/linters/magic_numbers/typescript_analyzer.py, src/analyzers/typescript_base.py
+
+Overview: Analyzes TypeScript and JavaScript code to detect console.* method calls that should
+    be replaced with proper logging. Uses Tree-sitter parser to traverse TypeScript/JavaScript
+    AST and identify call expressions where the callee is console.log, console.warn, console.error,
+    console.debug, or console.info (configurable). Returns structured data with the node, method
+    name, and line number for each detected console call. Supports both TypeScript and JavaScript
+    files with shared detection logic.
+
+Usage: analyzer = TypeScriptPrintStatementAnalyzer()
+    root = analyzer.parse_typescript(code)
+    calls = analyzer.find_console_calls(root, {"log", "warn", "error"})
+
+Notes: Tree-sitter node traversal with call_expression and member_expression pattern matching
+"""
+
+import logging
+from typing import Any
+
+from src.analyzers.typescript_base import TypeScriptBaseAnalyzer
+
+logger = logging.getLogger(__name__)
+
+# dry: ignore-block - tree-sitter import pattern (common across TypeScript analyzers)
+try:
+    from tree_sitter import Node
+
+    TREE_SITTER_AVAILABLE = True
+except ImportError:
+    TREE_SITTER_AVAILABLE = False
+    Node = Any  # type: ignore
+
+
+class TypeScriptPrintStatementAnalyzer(TypeScriptBaseAnalyzer):
+    """Analyzes TypeScript/JavaScript code for console.* calls using Tree-sitter."""
+
+    def find_console_calls(self, root_node: Node, methods: set[str]) -> list[tuple[Node, str, int]]:
+        """Find all console.* calls matching the specified methods.
+
+        Args:
+            root_node: Root tree-sitter node to search from
+            methods: Set of console method names to detect (e.g., {"log", "warn"})
+
+        Returns:
+            List of (node, method_name, line_number) tuples for each console call
+        """
+        logger.debug(
+            "find_console_calls: TREE_SITTER_AVAILABLE=%s, root_node=%s",
+            TREE_SITTER_AVAILABLE,
+            root_node is not None,
+        )
+        if not TREE_SITTER_AVAILABLE or root_node is None:
+            logger.debug("Early return: tree-sitter not available or root_node is None")
+            return []
+
+        calls: list[tuple[Node, str, int]] = []
+        self._collect_console_calls(root_node, methods, calls)
+        logger.debug("find_console_calls: found %d calls", len(calls))
+        return calls
+
+    def _collect_console_calls(
+        self, node: Node, methods: set[str], calls: list[tuple[Node, str, int]]
+    ) -> None:
+        """Recursively collect console.* calls from AST.
+
+        Args:
+            node: Current tree-sitter node
+            methods: Set of console method names to detect
+            calls: List to accumulate found calls
+        """
+        if node.type == "call_expression":
+            method_name = self._extract_console_method(node, methods)
+            if method_name is not None:
+                line_number = node.start_point[0] + 1
+                calls.append((node, method_name, line_number))
+
+        for child in node.children:
+            self._collect_console_calls(child, methods, calls)
+
+    def _extract_console_method(self, node: Node, methods: set[str]) -> str | None:
+        """Extract console method name if this is a console.* call.
+
+        Args:
+            node: Tree-sitter call_expression node
+            methods: Set of console method names to detect
+
+        Returns:
+            Method name if this is a matching console call, None otherwise
+        """
+        func_node = self.find_child_by_type(node, "member_expression")
+        if func_node is None:
+            return None
+        if not self._is_console_object(func_node):
+            return None
+        return self._get_matching_method(func_node, methods)
+
+    def _is_console_object(self, func_node: Node) -> bool:
+        """Check if the member expression is on 'console' object."""
+        object_node = self._find_object_node(func_node)
+        if object_node is None:
+            return False
+        return self.extract_node_text(object_node) == "console"
+
+    def _get_matching_method(self, func_node: Node, methods: set[str]) -> str | None:
+        """Get method name if it matches the configured methods."""
+        method_node = self.find_child_by_type(func_node, "property_identifier")
+        if method_node is None:
+            return None
+        method_name = self.extract_node_text(method_node)
+        return method_name if method_name in methods else None
+
+    def _find_object_node(self, member_expr: Node) -> Node | None:
+        """Find the object node in a member expression.
+
+        Args:
+            member_expr: Tree-sitter member_expression node
+
+        Returns:
+            Object node (identifier) or None
+        """
+        for child in member_expr.children:
+            if child.type == "identifier":
+                return child
+        return None

src/linters/print_statements/violation_builder.py

@@ -0,0 +1,98 @@
+"""
+File: src/linters/print_statements/violation_builder.py
+
+Purpose: Builds Violation objects for print statement detection
+
+Exports: ViolationBuilder class
+
+Depends: ast, pathlib.Path, src.core.types.Violation
+
+Implements: ViolationBuilder.create_python_violation(node, line, file_path) -> Violation,
+    ViolationBuilder.create_typescript_violation(method, line, file_path) -> Violation
+
+Related: src/linters/magic_numbers/violation_builder.py, src/core/types.py
+
+Overview: Provides ViolationBuilder class that creates Violation objects for print statement
+    detections. Generates descriptive messages suggesting the use of proper logging instead of
+    print/console statements. Constructs complete Violation instances with rule_id, file_path,
+    line number, column, message, and suggestions. Provides separate methods for Python print()
+    violations and TypeScript/JavaScript console.* violations with language-appropriate messages.
+
+Usage: builder = ViolationBuilder("print-statements.detected")
+    violation = builder.create_python_violation(node, line, file_path)
+
+Notes: Message templates suggest logging as alternative, consistent with other linter patterns
+"""
+
+import ast
+from pathlib import Path
+
+from src.core.types import Violation
+
+
+class ViolationBuilder:
+    """Builds violations for print statement detections."""
+
+    def __init__(self, rule_id: str) -> None:
+        """Initialize the violation builder.
+
+        Args:
+            rule_id: The rule ID to use in violations
+        """
+        self.rule_id = rule_id
+
+    def create_python_violation(
+        self,
+        node: ast.Call,
+        line: int,
+        file_path: Path | None,
+    ) -> Violation:
+        """Create a violation for a Python print() call.
+
+        Args:
+            node: The AST Call node containing the print statement
+            line: Line number where the violation occurs
+            file_path: Path to the file
+
+        Returns:
+            Violation object with details about the print statement
+        """
+        message = "print() statement should be replaced with proper logging"
+        suggestion = "Use logging.info(), logging.debug(), or similar instead of print()"
+
+        return Violation(
+            rule_id=self.rule_id,
+            file_path=str(file_path) if file_path else "",
+            line=line,
+            column=node.col_offset if hasattr(node, "col_offset") else 0,
+            message=message,
+            suggestion=suggestion,
+        )
+
+    def create_typescript_violation(
+        self,
+        method: str,
+        line: int,
+        file_path: Path | None,
+    ) -> Violation:
+        """Create a violation for a TypeScript/JavaScript console.* call.
+
+        Args:
+            method: The console method name (log, warn, error, etc.)
+            line: Line number where the violation occurs
+            file_path: Path to the file
+
+        Returns:
+            Violation object with details about the console statement
+        """
+        message = f"console.{method}() should be replaced with proper logging"
+        suggestion = f"Use a logging library instead of console.{method}()"
+
+        return Violation(
+            rule_id=self.rule_id,
+            file_path=str(file_path) if file_path else "",
+            line=line,
+            column=0,  # Tree-sitter nodes don't provide easy column access
+            message=message,
+            suggestion=suggestion,
+        )

src/linters/srp/__init__.py

@@ -22,7 +22,7 @@ Implementation: Simple re-export pattern for package interface, convenience func
 from pathlib import Path
 from typing import Any
 
-from .config import SRPConfig
+from .config import DEFAULT_MAX_LOC_PER_CLASS, DEFAULT_MAX_METHODS_PER_CLASS, SRPConfig
 from .linter import SRPRule
 from .python_analyzer import PythonSRPAnalyzer
 from .typescript_analyzer import TypeScriptSRPAnalyzer
@@ -39,8 +39,8 @@ __all__ = [
 def lint(
     path: Path | str,
     config: dict[str, Any] | None = None,
-    max_methods: int = 7,
-    max_loc: int = 200,
+    max_methods: int = DEFAULT_MAX_METHODS_PER_CLASS,
+    max_loc: int = DEFAULT_MAX_LOC_PER_CLASS,
 ) -> list:
     """Lint a file or directory for SRP violations.
 

src/linters/srp/config.py

@@ -23,13 +23,17 @@ Implementation: Dataclass with validation and defaults, heuristic-based SRP dete
 from dataclasses import dataclass, field
 from typing import Any
 
+# Default SRP threshold constants
+DEFAULT_MAX_METHODS_PER_CLASS = 7
+DEFAULT_MAX_LOC_PER_CLASS = 200
+
 
 @dataclass
 class SRPConfig:
     """Configuration for SRP linter."""
 
-    max_methods: int = 7  # Maximum methods per class
-    max_loc: int = 200  # Maximum lines of code per class
+    max_methods: int = DEFAULT_MAX_METHODS_PER_CLASS  # Maximum methods per class
+    max_loc: int = DEFAULT_MAX_LOC_PER_CLASS  # Maximum lines of code per class
     enabled: bool = True
     check_keywords: bool = True
     keywords: list[str] = field(
@@ -58,11 +62,13 @@ class SRPConfig:
         # Get language-specific config if available
         if language and language in config:
             lang_config = config[language]
-            max_methods = lang_config.get("max_methods", config.get("max_methods", 7))
-            max_loc = lang_config.get("max_loc", config.get("max_loc", 200))
+            max_methods = lang_config.get(
+                "max_methods", config.get("max_methods", DEFAULT_MAX_METHODS_PER_CLASS)
+            )
+            max_loc = lang_config.get("max_loc", config.get("max_loc", DEFAULT_MAX_LOC_PER_CLASS))
         else:
-            max_methods = config.get("max_methods", 7)
-            max_loc = config.get("max_loc", 200)
+            max_methods = config.get("max_methods", DEFAULT_MAX_METHODS_PER_CLASS)
+            max_loc = config.get("max_loc", DEFAULT_MAX_LOC_PER_CLASS)
 
         return cls(
             max_methods=max_methods,

src/linters/srp/linter.py

@@ -18,8 +18,8 @@ Interfaces: SRPRule.check(context) -> list[Violation], properties for rule metad
 Implementation: Composition pattern with helper classes, heuristic-based SRP analysis
 """
 
-from src.core.base import BaseLintContext, BaseLintRule
-from src.core.linter_utils import has_file_content, load_linter_config
+from src.core.base import BaseLintContext, MultiLanguageLintRule
+from src.core.linter_utils import load_linter_config
 from src.core.types import Violation
 from src.linter_config.ignore import IgnoreDirectiveParser
 
@@ -29,7 +29,7 @@ from .metrics_evaluator import evaluate_metrics
 from .violation_builder import ViolationBuilder
 
 
-class SRPRule(BaseLintRule):
+class SRPRule(MultiLanguageLintRule):
     """Detects Single Responsibility Principle violations in classes."""
 
     def __init__(self) -> None:
@@ -54,7 +54,9 @@ class SRPRule(BaseLintRule):
         return "Classes should have a single, well-defined responsibility"
 
     def check(self, context: BaseLintContext) -> list[Violation]:
-        """Check for SRP violations.
+        """Check for SRP violations with custom ignore pattern handling.
+
+        Overrides parent to add file-level ignore pattern checking before dispatch.
 
         Args:
             context: Lint context with file information
@@ -62,39 +64,33 @@ class SRPRule(BaseLintRule):
         Returns:
             List of violations found
         """
-        if not self._should_check_file(context):
-            return []
+        from src.core.linter_utils import has_file_content
 
-        config = load_linter_config(context, "srp", SRPConfig)
-        if not self._is_linter_enabled(context, config):
+        if not has_file_content(context):
             return []
 
-        return self._check_by_language(context, config)
-
-    def _should_check_file(self, context: BaseLintContext) -> bool:
-        """Check if file has content to analyze.
-
-        Args:
-            context: Lint context
+        config = self._load_config(context)
+        if not self._should_process_file(context, config):
+            return []
 
-        Returns:
-            True if file should be checked
-        """
-        return has_file_content(context)
+        # Standard language dispatch
+        return self._dispatch_by_language(context, config)
 
-    def _is_linter_enabled(self, context: BaseLintContext, config: SRPConfig) -> bool:
-        """Check if linter is enabled and file is not ignored.
+    def _should_process_file(self, context: BaseLintContext, config: SRPConfig) -> bool:
+        """Check if file should be processed.
 
         Args:
             context: Lint context
             config: SRP configuration
 
         Returns:
-            True if linter should run on this file
+            True if file should be processed
         """
-        return config.enabled and not self._is_file_ignored(context, config)
+        if not config.enabled:
+            return False
+        return not self._is_file_ignored(context, config)
 
-    def _check_by_language(self, context: BaseLintContext, config: SRPConfig) -> list[Violation]:
+    def _dispatch_by_language(self, context: BaseLintContext, config: SRPConfig) -> list[Violation]:
         """Dispatch to language-specific checker.
 
         Args:
@@ -106,10 +102,23 @@ class SRPRule(BaseLintRule):
         """
         if context.language == "python":
             return self._check_python(context, config)
+
         if context.language in ("typescript", "javascript"):
             return self._check_typescript(context, config)
+
         return []
 
+    def _load_config(self, context: BaseLintContext) -> SRPConfig:
+        """Load configuration from context.
+
+        Args:
+            context: Lint context
+
+        Returns:
+            SRPConfig instance
+        """
+        return load_linter_config(context, "srp", SRPConfig)
+
     def _is_file_ignored(self, context: BaseLintContext, config: SRPConfig) -> bool:
         """Check if file matches ignore patterns.
 

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()

src/templates/thailint_config_template.yaml

@@ -0,0 +1,158 @@
+# thai-lint Configuration File
+# Generated by: thailint init-config
+#
+# For non-interactive mode (AI agents): thailint init-config --non-interactive
+#
+# Full documentation: https://github.com/your-org/thai-lint
+
+# ============================================================================
+# MAGIC NUMBERS LINTER
+# ============================================================================
+# Detects unnamed numeric literals that should be extracted as constants
+#
+# Preset: {{PRESET}}
+#
+magic-numbers:
+  enabled: true
+
+  # Numbers that are acceptable without being named constants
+  # Default: [-1, 0, 1, 2, 3, 4, 5, 10, 100, 1000]
+  allowed_numbers: {{ALLOWED_NUMBERS}}
+
+  # Maximum integer allowed in range() or enumerate() without flagging
+  # Default: 10
+  max_small_integer: {{MAX_SMALL_INTEGER}}
+
+  # -------------------------------------------------------------------------
+  # OPTIONAL: Uncomment to add time conversions (lenient mode)
+  # -------------------------------------------------------------------------
+  # allowed_numbers: [-1, 0, 1, 2, 3, 4, 5, 10, 60, 100, 1000, 3600]
+
+  # -------------------------------------------------------------------------
+  # OPTIONAL: Uncomment to add common HTTP status codes
+  # -------------------------------------------------------------------------
+  # allowed_numbers: [-1, 0, 1, 2, 3, 4, 5, 10, 100, 200, 201, 204, 400, 401, 403, 404, 500, 502, 503, 1000]
+
+  # -------------------------------------------------------------------------
+  # OPTIONAL: Uncomment to add decimal proportions (0.0-1.0)
+  # -------------------------------------------------------------------------
+  # allowed_numbers: [-1, 0, 1, 2, 3, 4, 5, 10, 100, 1000, 0.0, 0.1, 0.2, 0.25, 0.3, 0.4, 0.5, 0.6, 0.7, 0.75, 0.8, 0.9, 1.0]
+
+# ============================================================================
+# NESTING LINTER
+# ============================================================================
+# Checks for excessive nesting depth (if/for/while/try statements)
+#
+nesting:
+  enabled: true
+
+  # Maximum nesting depth allowed
+  # Default: 4
+  max_nesting_depth: 4
+
+# ============================================================================
+# SINGLE RESPONSIBILITY PRINCIPLE (SRP) LINTER
+# ============================================================================
+# Detects classes that may have too many responsibilities
+#
+srp:
+  enabled: true
+
+  # Maximum methods per class
+  # Default: 7
+  max_methods: 7
+
+  # Maximum lines of code per class
+  # Default: 200
+  max_loc: 200
+
+# ============================================================================
+# DRY (DON'T REPEAT YOURSELF) LINTER
+# ============================================================================
+# Detects duplicate code blocks
+#
+dry:
+  enabled: true
+
+  # Minimum lines for a block to be considered duplicate
+  # Default: 6
+  min_duplicate_lines: 6
+
+  # Enable SQLite caching for faster incremental scans
+  # Default: true
+  cache_enabled: true
+
+  # Cache file location (relative to project root)
+  # Default: .thailint-cache/dry.db
+  cache_path: .thailint-cache/dry.db
+
+# ============================================================================
+# FILE PLACEMENT LINTER
+# ============================================================================
+# Ensures files are in appropriate directories
+#
+file-placement:
+  enabled: true
+
+  # Rules for file placement
+  rules:
+    # Test files should be in tests/ directory
+    - pattern: "test_*.py"
+      required_dir: "tests/"
+      message: "Test files must be in tests/ directory"
+
+    # Config files should be in config/ or root
+    - pattern: "*config*.py"
+      required_dir: ["config/", "./"]
+      message: "Config files should be in config/ or project root"
+
+# ============================================================================
+# PRINT STATEMENTS LINTER
+# ============================================================================
+# Detects print()/console.* statements that should use proper logging
+#
+print-statements:
+  enabled: true
+
+  # Allow print() in if __name__ == "__main__": blocks (Python only)
+  # Default: true
+  allow_in_scripts: true
+
+  # Console methods to detect in TypeScript/JavaScript
+  # Default: [log, warn, error, debug, info]
+  console_methods:
+    - log
+    - warn
+    - error
+    - debug
+    - info
+
+  # File patterns to ignore (glob syntax)
+  # ignore:
+  #   - "scripts/**"
+  #   - "**/debug.py"
+
+# ============================================================================
+# GLOBAL SETTINGS
+# ============================================================================
+#
+# Exclude patterns (files/directories to ignore)
+exclude:
+  - ".git/"
+  - ".venv/"
+  - "venv/"
+  - "node_modules/"
+  - "__pycache__/"
+  - "*.pyc"
+  - ".pytest_cache/"
+  - "dist/"
+  - "build/"
+  - ".eggs/"
+
+# Output format (text or json)
+# Default: text
+output_format: text
+
+# Exit with error code if violations found
+# Default: true
+fail_on_violations: true