thailint 0.15.8__py3-none-any.whl → 0.17.0__py3-none-any.whl

src/cli/linters/structure.py

@@ -25,12 +25,12 @@ Suppressions:
 """
 
 import json
-import logging
 import sys
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, NoReturn
 
 import click
+from loguru import logger
 
 from src.cli.linters.shared import (
     ensure_config_section,
@@ -54,10 +54,6 @@ from src.core.types import Violation
 if TYPE_CHECKING:
     from src.orchestrator.core import Orchestrator
 
-# Configure module logger
-logger = logging.getLogger(__name__)
-
-
 # =============================================================================
 # File Placement Command
 # =============================================================================
@@ -93,8 +89,7 @@ def _apply_inline_rules(orchestrator: "Orchestrator", rules: str, verbose: bool)
     """Parse and apply inline JSON rules."""
     rules_config = _parse_json_rules(rules)
     orchestrator.config.update(rules_config)
-    if verbose:
-        logger.debug(f"Applied inline rules: {rules_config}")
+    logger.debug(f"Applied inline rules: {rules_config}")
 
 
 def _parse_json_rules(rules: str) -> dict[str, Any]:
@@ -195,8 +190,7 @@ def _execute_file_placement_lint(  # pylint: disable=too-many-arguments,too-many
     # Filter to only file-placement violations
     violations = [v for v in all_violations if v.rule_id.startswith("file-placement")]
 
-    if verbose:
-        logger.info(f"Found {len(violations)} violation(s)")
+    logger.debug(f"Found {len(violations)} violation(s)")
 
     format_violations(violations, format)
     sys.exit(1 if violations else 0)
@@ -320,8 +314,7 @@ def _execute_pipeline_lint(  # pylint: disable=too-many-arguments,too-many-posit
     _apply_pipeline_config_override(orchestrator, min_continues, verbose)
     pipeline_violations = _run_pipeline_lint(orchestrator, path_objs, recursive, parallel)
 
-    if verbose:
-        logger.info(f"Found {len(pipeline_violations)} collection-pipeline violation(s)")
+    logger.debug(f"Found {len(pipeline_violations)} collection-pipeline violation(s)")
 
     format_violations(pipeline_violations, format)
     sys.exit(1 if pipeline_violations else 0)

src/cli/linters/structure_quality.py

@@ -24,13 +24,13 @@ Suppressions:
     - too-many-arguments,too-many-positional-arguments: Click commands require many parameters by framework design
 """
 
-import logging
 import sys
 from contextlib import suppress
 from pathlib import Path
 from typing import TYPE_CHECKING, NoReturn
 
 import click
+from loguru import logger
 
 from src.cli.linters.shared import (
     ensure_config_section,
@@ -52,10 +52,6 @@ from src.core.types import Violation
 if TYPE_CHECKING:
     from src.orchestrator.core import Orchestrator
 
-# Configure module logger
-logger = logging.getLogger(__name__)
-
-
 # =============================================================================
 # Nesting Command
 # =============================================================================
@@ -79,8 +75,7 @@ def _apply_nesting_config_override(
     nesting_config["max_nesting_depth"] = max_depth
     _apply_nesting_to_languages(nesting_config, max_depth)
 
-    if verbose:
-        logger.debug(f"Overriding max_nesting_depth to {max_depth}")
+    logger.debug(f"Overriding max_nesting_depth to {max_depth}")
 
 
 def _apply_nesting_to_languages(nesting_config: dict, max_depth: int) -> None:
@@ -189,8 +184,7 @@ def _execute_nesting_lint(  # pylint: disable=too-many-arguments,too-many-positi
     _apply_nesting_config_override(orchestrator, max_depth, verbose)
     nesting_violations = _run_nesting_lint(orchestrator, path_objs, recursive, parallel)
 
-    if verbose:
-        logger.info(f"Found {len(nesting_violations)} nesting violation(s)")
+    logger.debug(f"Found {len(nesting_violations)} nesting violation(s)")
 
     format_violations(nesting_violations, format)
     sys.exit(1 if nesting_violations else 0)
@@ -321,8 +315,7 @@ def _execute_srp_lint(  # pylint: disable=too-many-arguments,too-many-positional
     _apply_srp_config_override(orchestrator, max_methods, max_loc, verbose)
     srp_violations = _run_srp_lint(orchestrator, path_objs, recursive, parallel)
 
-    if verbose:
-        logger.info(f"Found {len(srp_violations)} SRP violation(s)")
+    logger.debug(f"Found {len(srp_violations)} SRP violation(s)")
 
     format_violations(srp_violations, format)
     sys.exit(1 if srp_violations else 0)

src/cli/main.py

@@ -21,32 +21,29 @@ Implementation: Uses Click decorators for group definition, stores parsed option
     in test environments.
 """
 
-import logging
 import sys
 from pathlib import Path
 
 import click
+from loguru import logger
 
 from src import __version__
 from src.config import ConfigError, load_config
 
-# Configure module logger
-logger = logging.getLogger(__name__)
-
 
 def setup_logging(verbose: bool = False) -> None:
-    """Configure logging for the CLI application.
+    """Configure loguru for the CLI application.
 
     Args:
-        verbose: Enable DEBUG level logging if True, INFO otherwise.
+        verbose: Enable DEBUG level logging if True, WARNING otherwise.
     """
-    level = logging.DEBUG if verbose else logging.INFO
-
-    logging.basicConfig(
+    logger.remove()  # Remove default handler
+    level = "DEBUG" if verbose else "WARNING"
+    logger.add(
+        sys.stderr,
         level=level,
-        format="%(asctime)s | %(levelname)-8s | %(message)s",
-        datefmt="%Y-%m-%d %H:%M:%S",
-        stream=sys.stdout,
+        format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level:<8}</level> | <level>{message}</level>",
+        colorize=True,
     )
 
 

src/cli/utils.py

@@ -21,7 +21,6 @@ Implementation: Uses Click decorators for option definitions, deferred imports f
     to support test environments, caches project root in context for efficiency
 """
 
-import logging
 import sys
 from collections.abc import Callable
 from contextlib import suppress
@@ -29,13 +28,11 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, TypeVar, cast
 
 import click
+from loguru import logger
 
 if TYPE_CHECKING:
     from src.orchestrator.core import Orchestrator
 
-# Configure module logger
-logger = logging.getLogger(__name__)
-
 
 # =============================================================================
 # Common Option Decorators
@@ -132,8 +129,7 @@ def _resolve_explicit_project_root(explicit_root: str, verbose: bool) -> Path:
     # Now resolve after validation
     root = root.resolve()
 
-    if verbose:
-        logger.debug(f"Using explicit project root: {root}")
+    logger.debug(f"Using explicit project root: {root}")
     return root
 
 
@@ -150,8 +146,7 @@ def _infer_root_from_config(config_path: str, verbose: bool) -> Path:
     config_file = Path(config_path).resolve()
     inferred_root = config_file.parent
 
-    if verbose:
-        logger.debug(f"Inferred project root from config path: {inferred_root}")
+    logger.debug(f"Inferred project root from config path: {inferred_root}")
     return inferred_root
 
 
@@ -168,8 +163,7 @@ def _autodetect_project_root(
         Auto-detected project root
     """
     auto_root = get_project_root(None)
-    if verbose:
-        logger.debug(f"Auto-detected project root: {auto_root}")
+    logger.debug(f"Auto-detected project root: {auto_root}")
     return auto_root
 
 
@@ -217,8 +211,7 @@ def _determine_project_root_for_context(ctx: click.Context) -> Path | None:
         return _infer_root_from_config(config_path, verbose)
 
     # No explicit root - return None for auto-detection from target paths
-    if verbose:
-        logger.debug("No explicit project root, will auto-detect from target paths")
+    logger.debug("No explicit project root, will auto-detect from target paths")
     return None
 
 
@@ -262,8 +255,7 @@ def handle_linting_error(error: Exception, verbose: bool) -> None:
         verbose: Whether verbose logging is enabled
     """
     click.echo(f"Error during linting: {error}", err=True)
-    if verbose:
-        logger.exception("Linting failed with exception")
+    logger.exception("Linting failed with exception")
     sys.exit(2)
 
 
@@ -334,8 +326,7 @@ def load_config_file(orchestrator: "Orchestrator", config_file: str, verbose: bo
     # Load config into orchestrator
     orchestrator.config = orchestrator.config_loader.load(config_path)
 
-    if verbose:
-        logger.debug(f"Loaded config from: {config_file}")
+    logger.debug(f"Loaded config from: {config_file}")
 
 
 # =============================================================================

src/core/__init__.py

@@ -6,12 +6,26 @@ power the plugin architecture.
 
 from .base import BaseLintContext, BaseLintRule
 from .registry import RuleRegistry
+from .rule_aliases import (
+    LINTER_ALIASES,
+    RULE_ID_ALIASES,
+    is_deprecated_linter,
+    is_deprecated_rule_id,
+    resolve_linter_name,
+    resolve_rule_id,
+)
 from .types import Severity, Violation
 
 __all__ = [
     "BaseLintContext",
     "BaseLintRule",
+    "LINTER_ALIASES",
+    "RULE_ID_ALIASES",
     "RuleRegistry",
     "Severity",
     "Violation",
+    "is_deprecated_linter",
+    "is_deprecated_rule_id",
+    "resolve_linter_name",
+    "resolve_rule_id",
 ]

src/core/base.py

@@ -177,12 +177,27 @@ class MultiLanguageLintRule(BaseLintRule):
         if not config.enabled:
             return []
 
+        return self._dispatch_by_language(context, config)
+
+    def _dispatch_by_language(self, context: BaseLintContext, config: Any) -> list[Violation]:
+        """Dispatch to language-specific check method.
+
+        Args:
+            context: Lint context with language information
+            config: Loaded configuration
+
+        Returns:
+            List of violations from language-specific checker
+        """
         if context.language == Language.PYTHON:
             return self._check_python(context, config)
 
         if context.language in (Language.TYPESCRIPT, Language.JAVASCRIPT):
             return self._check_typescript(context, config)
 
+        if context.language == Language.RUST:
+            return self._check_rust(context, config)
+
         return []
 
     @abstractmethod
@@ -222,3 +237,18 @@ class MultiLanguageLintRule(BaseLintRule):
             List of violations found in TypeScript/JavaScript code
         """
         raise NotImplementedError("Subclasses must implement _check_typescript")
+
+    def _check_rust(self, context: BaseLintContext, config: Any) -> list[Violation]:
+        """Check Rust code for violations.
+
+        Override in subclasses to add Rust language support.
+        Returns empty list by default for linters that do not support Rust.
+
+        Args:
+            context: Lint context with Rust file information
+            config: Loaded configuration
+
+        Returns:
+            List of violations found in Rust code
+        """
+        return []

src/core/constants.py

@@ -28,6 +28,7 @@ class Language(str, Enum):
     TYPESCRIPT = "typescript"
     JAVASCRIPT = "javascript"
     MARKDOWN = "markdown"
+    RUST = "rust"
 
 
 class StorageMode(str, Enum):

src/core/linter_utils.py

@@ -13,7 +13,7 @@ Overview: Provides reusable helper functions to eliminate duplication across lin
 Dependencies: BaseLintContext from src.core.base, ast for Python parsing
 
 Exports: get_metadata, get_metadata_value, load_linter_config, has_file_content, parse_python_ast,
-    with_parsed_python
+    with_parsed_python, resolve_file_path, is_ignored_path, get_line_context
 
 Interfaces: All functions take BaseLintContext and return typed values (dict, str, bool, Any)
 
@@ -255,3 +255,44 @@ def with_parsed_python(
     # tree is guaranteed non-None when errors is empty (parse_python_ast contract)
     assert tree is not None  # nosec B101
     return on_success(tree)
+
+
+def resolve_file_path(context: BaseLintContext) -> str:
+    """Resolve file path from context.
+
+    Args:
+        context: Lint context
+
+    Returns:
+        File path string, or "unknown" if not available
+    """
+    return str(context.file_path) if context.file_path else "unknown"
+
+
+def is_ignored_path(file_path: str, ignore_patterns: list[str]) -> bool:
+    """Check if file path matches any ignore pattern.
+
+    Args:
+        file_path: Path to check
+        ignore_patterns: List of patterns to match against
+
+    Returns:
+        True if the path should be ignored
+    """
+    return any(ignored in file_path for ignored in ignore_patterns)
+
+
+def get_line_context(code: str, line_index: int) -> str:
+    """Get the code line at the given index for context.
+
+    Args:
+        code: Full source code
+        line_index: Zero-indexed line number
+
+    Returns:
+        Stripped line content, or empty string if index out of range
+    """
+    lines = code.split("\n")
+    if 0 <= line_index < len(lines):
+        return lines[line_index].strip()
+    return ""

src/core/rule_aliases.py

@@ -0,0 +1,84 @@
+"""
+Purpose: Rule ID aliasing system for backward compatibility during rule renaming
+
+Scope: Maps deprecated rule IDs to canonical rule IDs for configuration and filtering
+
+Overview: Provides a mapping system for rule IDs that allows backward compatibility when rules
+    are renamed. Users can continue using deprecated rule IDs in configuration files and ignore
+    directives, which are transparently resolved to their canonical forms. Supports both
+    direct rule ID mapping and linter-level command aliasing. Used by configuration parsing,
+    violation filtering, and ignore directive processing.
+
+Dependencies: None (pure Python module)
+
+Exports: RULE_ID_ALIASES dict, LINTER_ALIASES dict, resolve_rule_id function,
+    resolve_linter_name function
+
+Interfaces: resolve_rule_id(rule_id) -> str, resolve_linter_name(name) -> str
+
+Implementation: Simple dictionary-based lookup with identity fallback for unknown rule IDs
+"""
+
+# Maps deprecated rule IDs to their canonical replacements
+RULE_ID_ALIASES: dict[str, str] = {
+    "print-statements.detected": "improper-logging.print-statement",
+}
+
+# Maps deprecated linter command names to their canonical replacements
+LINTER_ALIASES: dict[str, str] = {
+    "print-statements": "improper-logging",
+}
+
+
+def resolve_rule_id(rule_id: str) -> str:
+    """Resolve a rule ID to its canonical form.
+
+    If the rule ID has been renamed, returns the new canonical name.
+    Otherwise, returns the rule ID unchanged.
+
+    Args:
+        rule_id: The rule ID to resolve (may be deprecated or canonical)
+
+    Returns:
+        The canonical rule ID
+    """
+    return RULE_ID_ALIASES.get(rule_id, rule_id)
+
+
+def resolve_linter_name(name: str) -> str:
+    """Resolve a linter command name to its canonical form.
+
+    If the linter has been renamed, returns the new canonical name.
+    Otherwise, returns the name unchanged.
+
+    Args:
+        name: The linter command name to resolve (may be deprecated or canonical)
+
+    Returns:
+        The canonical linter name
+    """
+    return LINTER_ALIASES.get(name, name)
+
+
+def is_deprecated_rule_id(rule_id: str) -> bool:
+    """Check if a rule ID is deprecated.
+
+    Args:
+        rule_id: The rule ID to check
+
+    Returns:
+        True if the rule ID is deprecated (has an alias)
+    """
+    return rule_id in RULE_ID_ALIASES
+
+
+def is_deprecated_linter(name: str) -> bool:
+    """Check if a linter name is deprecated.
+
+    Args:
+        name: The linter name to check
+
+    Returns:
+        True if the linter name is deprecated (has an alias)
+    """
+    return name in LINTER_ALIASES

src/linter_config/rule_matcher.py

@@ -4,32 +4,46 @@ Purpose: Rule ID matching utilities for ignore directive processing
 Scope: Pattern matching between rule IDs and ignore patterns
 
 Overview: Provides functions for matching rule IDs against ignore patterns. Supports
-    exact matching, wildcard matching (*.suffix), and prefix matching (category matches
-    category.specific). All comparisons are case-insensitive to handle variations in
-    rule ID formatting.
+    exact matching, wildcard matching (*.suffix), prefix matching (category matches
+    category.specific), and alias resolution for backward compatibility with renamed
+    rules. All comparisons are case-insensitive to handle variations in rule ID formatting.
 
-Dependencies: re for regex operations
+Dependencies: re for regex operations, src.core.rule_aliases for alias resolution
 
 Exports: rule_matches, check_bracket_rules, check_space_separated_rules
 
 Interfaces: rule_matches(rule_id, pattern) -> bool for checking if rule matches pattern
 
-Implementation: String-based pattern matching with wildcard and prefix support
+Implementation: String-based pattern matching with wildcard, prefix, and alias support
 """
 
 import re
 
+from src.core.rule_aliases import RULE_ID_ALIASES
+
 
 def rule_matches(rule_id: str, pattern: str) -> bool:
-    """Check if rule ID matches pattern (supports wildcards and prefixes).
+    """Check if rule ID matches pattern (supports wildcards, prefixes, and aliases).
+
+    Supports backward compatibility through alias resolution:
+    - Pattern "print-statements" matches rule_id "improper-logging.print-statement"
+    - Pattern "print-statements.*" matches rule_id "improper-logging.print-statement"
 
     Args:
-        rule_id: Rule ID to check (e.g., "nesting.excessive-depth").
-        pattern: Pattern with optional wildcard (e.g., "nesting.*" or "nesting").
+        rule_id: Rule ID to check (e.g., "improper-logging.print-statement").
+        pattern: Pattern with optional wildcard (e.g., "nesting.*" or "print-statements").
 
     Returns:
         True if rule matches pattern.
     """
+    if _matches_pattern_directly(rule_id, pattern):
+        return True
+
+    return _matches_via_alias(rule_id, pattern)
+
+
+def _matches_pattern_directly(rule_id: str, pattern: str) -> bool:
+    """Check if rule ID matches pattern without alias resolution."""
     rule_id_lower = rule_id.lower()
     pattern_lower = pattern.lower()
 
@@ -46,6 +60,37 @@ def rule_matches(rule_id: str, pattern: str) -> bool:
     return False
 
 
+def _matches_via_alias(rule_id: str, pattern: str) -> bool:
+    """Check if rule ID matches pattern through alias resolution."""
+    pattern_lower = pattern.lower()
+    rule_id_lower = rule_id.lower()
+
+    # Find deprecated IDs that alias to our rule_id and check pattern match
+    return any(
+        _pattern_matches_deprecated_id(pattern_lower, deprecated_id)
+        for deprecated_id, canonical_id in RULE_ID_ALIASES.items()
+        if canonical_id.lower() == rule_id_lower
+    )
+
+
+def _pattern_matches_deprecated_id(pattern_lower: str, deprecated_id: str) -> bool:
+    """Check if pattern matches a deprecated rule ID."""
+    deprecated_id_lower = deprecated_id.lower()
+
+    # Pattern exactly matches deprecated ID
+    if pattern_lower == deprecated_id_lower:
+        return True
+
+    # Pattern is prefix/wildcard that matches deprecated ID's category
+    deprecated_category = deprecated_id.split(".", maxsplit=1)[0].lower()
+    if pattern_lower == deprecated_category:
+        return True
+    if pattern_lower == deprecated_category + ".*":
+        return True
+
+    return False
+
+
 def check_bracket_rules(rules_text: str, rule_id: str) -> bool:
     """Check if bracketed rules match the rule ID.
 

src/linters/blocking_async/__init__.py

@@ -0,0 +1,31 @@
+"""
+Purpose: Rust blocking-in-async detector package exports
+
+Scope: Detect blocking operations inside async functions in Rust code and suggest alternatives
+
+Overview: Package providing blocking-in-async detection for Rust code. Identifies std::fs I/O
+    operations, std::thread::sleep calls, and blocking std::net operations inside async functions.
+    Suggests async-compatible alternatives including tokio::fs, tokio::time::sleep, and tokio::net
+    equivalents. Supports configuration for allowing calls in test code, toggling individual
+    pattern detection, and ignoring specific directories. Uses tree-sitter for accurate
+    AST-based detection of async function contexts.
+
+Dependencies: tree-sitter-rust (optional) for AST parsing, src.core for base classes
+
+Exports: BlockingAsyncConfig, BlockingAsyncRule, RustBlockingAsyncAnalyzer, BlockingCall
+
+Interfaces: BlockingAsyncConfig.from_dict() for YAML configuration loading
+
+Implementation: Tree-sitter AST-based async context detection with blocking API pattern matching
+"""
+
+from .config import BlockingAsyncConfig
+from .linter import BlockingAsyncRule
+from .rust_analyzer import BlockingCall, RustBlockingAsyncAnalyzer
+
+__all__ = [
+    "BlockingAsyncConfig",
+    "BlockingAsyncRule",
+    "RustBlockingAsyncAnalyzer",
+    "BlockingCall",
+]

src/linters/blocking_async/config.py

@@ -0,0 +1,67 @@
+"""
+Purpose: Configuration dataclass for Rust blocking-in-async detector
+
+Scope: Pattern toggles, ignore patterns, and configuration for blocking-in-async detection
+
+Overview: Provides BlockingAsyncConfig dataclass with toggles for controlling detection of
+    blocking operations inside async functions in Rust code. Supports toggling detection of
+    std::fs operations, std::thread::sleep, and blocking network calls independently. Includes
+    configuration for allowing calls in test code, ignoring example and benchmark directories.
+    Configuration loads from YAML with sensible defaults via from_dict() class method.
+
+Dependencies: dataclasses, typing
+
+Exports: BlockingAsyncConfig
+
+Interfaces: BlockingAsyncConfig.from_dict() for YAML configuration loading
+
+Implementation: Dataclass with factory defaults and conservative default settings
+"""
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class BlockingAsyncConfig:
+    """Configuration for blocking-in-async detection."""
+
+    enabled: bool = True
+
+    # Allow blocking calls in test functions and #[cfg(test)] modules
+    allow_in_tests: bool = True
+
+    # Toggle detection of std::fs operations in async functions
+    detect_fs_in_async: bool = True
+
+    # Toggle detection of std::thread::sleep in async functions
+    detect_sleep_in_async: bool = True
+
+    # Toggle detection of std::net blocking calls in async functions
+    detect_net_in_async: bool = True
+
+    # File path patterns to ignore (e.g., examples/, benches/)
+    ignore: list[str] = field(default_factory=lambda: ["examples/", "benches/", "tests/"])
+
+    @classmethod
+    def from_dict(
+        cls, config: dict[str, Any], language: str | None = None
+    ) -> "BlockingAsyncConfig":
+        """Load configuration from dictionary.
+
+        Args:
+            config: Configuration dictionary from YAML
+            language: Language parameter (reserved for future use)
+
+        Returns:
+            Configured BlockingAsyncConfig instance
+        """
+        _ = language
+        return cls(
+            enabled=config.get("enabled", True),
+            allow_in_tests=config.get("allow_in_tests", True),
+            detect_fs_in_async=config.get("detect_fs_in_async", True),
+            detect_sleep_in_async=config.get("detect_sleep_in_async", True),
+            detect_net_in_async=config.get("detect_net_in_async", True),
+            ignore=config.get("ignore", ["examples/", "benches/", "tests/"]),
+        )