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

src/cli/config.py

@@ -21,22 +21,18 @@ Implementation: Uses Click decorators for command definition, supports multiple
     validates configuration changes before saving, uses template file for init-config generation
 """
 
-import logging
 import sys
 from pathlib import Path
 
 import click
 import yaml
+from loguru import logger
 
 from src.config import ConfigError, save_config, validate_config
 
 from .config_merge import perform_merge
 from .main import cli
 
-# Configure module logger
-logger = logging.getLogger(__name__)
-
-
 # =============================================================================
 # Config Command Group
 # =============================================================================
@@ -177,8 +173,7 @@ def _save_and_report_success(
     """Save configuration and report success."""
     save_config(cfg, config_path)
     click.echo(f"Set {key} = {value}")
-    if verbose:
-        logger.info(f"Configuration updated: {key}={value}")
+    logger.debug(f"Configuration updated: {key}={value}")
 
 
 @config.command("set")
@@ -256,8 +251,7 @@ def config_reset(ctx: click.Context, yes: bool) -> None:
         save_config(DEFAULT_CONFIG.copy(), config_path)
         click.echo("Configuration reset to defaults")
 
-        if ctx.obj.get("verbose"):
-            logger.info("Configuration reset to defaults")
+        logger.debug("Configuration reset to defaults")
     except ConfigError as e:
         click.echo(f"Error resetting configuration: {e}", err=True)
         sys.exit(1)
@@ -462,7 +456,6 @@ def hello(ctx: click.Context, name: str, uppercase: bool) -> None:
         thai-lint hello --name Bob --uppercase
     """
     config = ctx.obj["config"]
-    verbose = ctx.obj.get("verbose", False)
 
     # Get greeting from config or use default
     greeting_template = config.get("greeting", "Hello")
@@ -476,5 +469,4 @@ def hello(ctx: click.Context, name: str, uppercase: bool) -> None:
     # Output greeting
     click.echo(message)
 
-    if verbose:
-        logger.info(f"Greeted {name} with template '{greeting_template}'")
+    logger.debug(f"Greeted {name} with template '{greeting_template}'")

src/cli/linters/__init__.py

@@ -1,13 +1,15 @@
 """
 Purpose: CLI linters package that registers all linter commands to the main CLI group
 
-Scope: Export and registration of all linter CLI commands (nesting, srp, dry, magic-numbers, etc.)
+Scope: Export and registration of all linter CLI commands (nesting, srp, dry, magic-numbers,
+    unwrap-abuse, clone-abuse, blocking-async, etc.)
 
 Overview: Package initialization that imports all linter command modules to trigger their registration
     with the main CLI group via Click decorators. Each submodule defines commands using @cli.command()
     decorators that automatically register with the CLI when imported. Organized by logical grouping:
-    structure_quality (nesting, srp), code_smells (dry, magic-numbers), code_patterns (print-statements,
+    structure_quality (nesting, srp), code_smells (dry, magic-numbers), code_patterns (improper-logging,
     method-property, stateless-class), structure (file-placement, pipeline), documentation (file-header).
+    Note: print-statements is a deprecated alias for improper-logging.
 
 Dependencies: Click for CLI framework, src.cli.main for CLI group, individual linter modules
 
@@ -28,12 +30,14 @@ from src.cli.linters import (  # noqa: F401
     code_smells,
     documentation,
     performance,
+    rust,
     structure,
     structure_quality,
 )
 
 # Re-export command functions for testing and reference
 from src.cli.linters.code_patterns import (
+    improper_logging,
     method_property,
     print_statements,
     stateless_class,
@@ -41,6 +45,7 @@ from src.cli.linters.code_patterns import (
 from src.cli.linters.code_smells import dry, magic_numbers
 from src.cli.linters.documentation import file_header
 from src.cli.linters.performance import perf, regex_in_loop, string_concat_loop
+from src.cli.linters.rust import blocking_async, clone_abuse, unwrap_abuse
 from src.cli.linters.structure import file_placement, pipeline
 from src.cli.linters.structure_quality import nesting, srp
 
@@ -52,7 +57,8 @@ __all__ = [
     "dry",
     "magic_numbers",
     # Code pattern commands
-    "print_statements",
+    "improper_logging",
+    "print_statements",  # deprecated alias for improper_logging
     "method_property",
     "stateless_class",
     # Structure commands
@@ -64,4 +70,8 @@ __all__ = [
     "perf",
     "string_concat_loop",
     "regex_in_loop",
+    # Rust commands
+    "unwrap_abuse",
+    "clone_abuse",
+    "blocking_async",
 ]

src/cli/linters/code_patterns.py

@@ -1,29 +1,31 @@
 """
-Purpose: CLI commands for code pattern linters (print-statements, method-property, stateless-class, lazy-ignores, lbyl)
+Purpose: CLI commands for code pattern linters (improper-logging, method-property, stateless-class, lazy-ignores, lbyl)
 
 Scope: Commands that detect code patterns and anti-patterns in Python code
 
-Overview: Provides CLI commands for code pattern linting: print-statements detects print() and
-    console.log calls that should use proper logging, method-property finds methods that should be
-    @property decorators, stateless-class detects classes without state that should be module
-    functions, lazy-ignores detects unjustified linting suppressions, and lbyl detects Look Before
-    You Leap anti-patterns. Each command supports standard options (config, format, recursive) and
-    integrates with the orchestrator for execution.
+Overview: Provides CLI commands for code pattern linting: improper-logging detects print() and
+    console.log calls that should use proper logging as well as conditional verbose patterns,
+    method-property finds methods that should be @property decorators, stateless-class detects
+    classes without state that should be module functions, lazy-ignores detects unjustified linting
+    suppressions, and lbyl detects Look Before You Leap anti-patterns. Each command supports
+    standard options (config, format, recursive) and integrates with the orchestrator for execution.
+    Note: print-statements is a deprecated alias for improper-logging.
 
 Dependencies: click for CLI framework, src.cli.main for CLI group, src.cli.utils for shared utilities
 
-Exports: print_statements, method_property, stateless_class, lazy_ignores, lbyl commands
+Exports: improper_logging, print_statements (alias), method_property, stateless_class, lazy_ignores, lbyl commands
 
 Interfaces: Click CLI commands registered to main CLI group
 
 Implementation: Click decorators for command definition, orchestrator-based linting execution
 """
 
-import logging
 import sys
 from pathlib import Path
 from typing import TYPE_CHECKING, NoReturn
 
+from loguru import logger
+
 from src.cli.linters.shared import ExecuteParams, create_linter_command
 from src.cli.utils import execute_linting_on_paths, setup_base_orchestrator, validate_paths_exist
 from src.core.cli_utils import format_violations
@@ -32,53 +34,59 @@ from src.core.types import Violation
 if TYPE_CHECKING:
     from src.orchestrator.core import Orchestrator
 
-# Configure module logger
-logger = logging.getLogger(__name__)
-
 
 # =============================================================================
-# Print Statements Command
+# Improper Logging Command (formerly print-statements)
 # =============================================================================
 
 
-def _setup_print_statements_orchestrator(
+def _setup_improper_logging_orchestrator(
     path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
 ) -> "Orchestrator":
-    """Set up orchestrator for print-statements command."""
+    """Set up orchestrator for improper-logging command."""
     return setup_base_orchestrator(path_objs, config_file, verbose, project_root)
 
 
-def _run_print_statements_lint(
+def _run_improper_logging_lint(
     orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
 ) -> list[Violation]:
-    """Execute print-statements lint on files or directories."""
+    """Execute improper-logging lint on files or directories."""
     all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
-    return [v for v in all_violations if "print-statement" in v.rule_id]
+    return [v for v in all_violations if v.rule_id.startswith("improper-logging.")]
 
 
-def _execute_print_statements_lint(params: ExecuteParams) -> NoReturn:
-    """Execute print-statements lint."""
+def _execute_improper_logging_lint(params: ExecuteParams) -> NoReturn:
+    """Execute improper-logging lint."""
     validate_paths_exist(params.path_objs)
-    orchestrator = _setup_print_statements_orchestrator(
+    orchestrator = _setup_improper_logging_orchestrator(
         params.path_objs, params.config_file, params.verbose, params.project_root
     )
-    print_statements_violations = _run_print_statements_lint(
+    improper_logging_violations = _run_improper_logging_lint(
         orchestrator, params.path_objs, params.recursive, params.parallel
     )
 
-    if params.verbose:
-        logger.info(f"Found {len(print_statements_violations)} print statement violation(s)")
+    logger.debug(f"Found {len(improper_logging_violations)} improper logging violation(s)")
 
-    format_violations(print_statements_violations, params.format)
-    sys.exit(1 if print_statements_violations else 0)
+    format_violations(improper_logging_violations, params.format)
+    sys.exit(1 if improper_logging_violations else 0)
 
 
+# Primary command
+improper_logging = create_linter_command(
+    "improper-logging",
+    _execute_improper_logging_lint,
+    "Check for improper logging patterns in code.",
+    "Detects print()/console statements and conditional verbose patterns that should\n"
+    "    be replaced with proper logging configuration.",
+)
+
+# Backward-compatible alias (deprecated)
 print_statements = create_linter_command(
     "print-statements",
-    _execute_print_statements_lint,
-    "Check for print/console statements in code.",
-    "Detects print() calls in Python and console.log/warn/error/debug/info calls\n"
-    "    in TypeScript/JavaScript that should be replaced with proper logging.",
+    _execute_improper_logging_lint,  # Same executor as improper-logging
+    "Alias for improper-logging (deprecated).",
+    "DEPRECATED: Use 'improper-logging' instead. Detects print() calls in Python and\n"
+    "    console.log/warn/error/debug/info calls in TypeScript/JavaScript.",
 )
 
 
@@ -112,8 +120,7 @@ def _execute_method_property_lint(params: ExecuteParams) -> NoReturn:
         orchestrator, params.path_objs, params.recursive, params.parallel
     )
 
-    if params.verbose:
-        logger.info(f"Found {len(method_property_violations)} method-property violation(s)")
+    logger.debug(f"Found {len(method_property_violations)} method-property violation(s)")
 
     format_violations(method_property_violations, params.format)
     sys.exit(1 if method_property_violations else 0)
@@ -159,8 +166,7 @@ def _execute_stateless_class_lint(params: ExecuteParams) -> NoReturn:
         orchestrator, params.path_objs, params.recursive, params.parallel
     )
 
-    if params.verbose:
-        logger.info(f"Found {len(stateless_class_violations)} stateless-class violation(s)")
+    logger.debug(f"Found {len(stateless_class_violations)} stateless-class violation(s)")
 
     format_violations(stateless_class_violations, params.format)
     sys.exit(1 if stateless_class_violations else 0)
@@ -206,8 +212,7 @@ def _execute_lazy_ignores_lint(params: ExecuteParams) -> NoReturn:
         orchestrator, params.path_objs, params.recursive, params.parallel
     )
 
-    if params.verbose:
-        logger.info(f"Found {len(lazy_ignores_violations)} lazy-ignores violation(s)")
+    logger.debug(f"Found {len(lazy_ignores_violations)} lazy-ignores violation(s)")
 
     format_violations(lazy_ignores_violations, params.format)
     sys.exit(1 if lazy_ignores_violations else 0)
@@ -253,8 +258,7 @@ def _execute_lbyl_lint(params: ExecuteParams) -> NoReturn:
         orchestrator, params.path_objs, params.recursive, params.parallel
     )
 
-    if params.verbose:
-        logger.info(f"Found {len(lbyl_violations)} LBYL violation(s)")
+    logger.debug(f"Found {len(lbyl_violations)} LBYL violation(s)")
 
     format_violations(lbyl_violations, params.format)
     sys.exit(1 if lbyl_violations else 0)

src/cli/linters/code_smells.py

@@ -23,13 +23,13 @@ Suppressions:
         many parameters by framework design (dry command has 8 params for extra options)
 """
 
-import logging
 import sys
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, NoReturn
 
 import click
 import yaml
+from loguru import logger
 
 from src.cli.linters.shared import (
     ExecuteParams,
@@ -53,10 +53,6 @@ from src.core.types import Violation
 if TYPE_CHECKING:
     from src.orchestrator.core import Orchestrator
 
-# Configure module logger
-logger = logging.getLogger(__name__)
-
-
 # =============================================================================
 # DRY Command (custom options - cannot use create_linter_command)
 # =============================================================================
@@ -87,8 +83,7 @@ def _load_dry_config_file(orchestrator: "Orchestrator", config_file: str, verbos
     except KeyError:
         return  # No DRY config in file
     orchestrator.config.update({"dry": dry_config})
-    if verbose:
-        logger.info(f"Loaded DRY config from {config_file}")
+    logger.debug(f"Loaded DRY config from {config_file}")
 
 
 def _apply_dry_config_override(
@@ -108,10 +103,9 @@ def _clear_dry_cache(orchestrator: "Orchestrator", verbose: bool) -> None:
 
     if cache_path.exists():
         cache_path.unlink()
-        if verbose:
-            logger.info(f"Cleared cache: {cache_path}")
-    elif verbose:
-        logger.info("Cache file does not exist, nothing to clear")
+        logger.debug(f"Cleared cache: {cache_path}")
+    else:
+        logger.debug("Cache file does not exist, nothing to clear")
 
 
 def _run_dry_lint(
@@ -242,8 +236,7 @@ def _execute_dry_lint(  # pylint: disable=too-many-arguments,too-many-positional
 
     dry_violations = _run_dry_lint(orchestrator, path_objs, recursive, parallel)
 
-    if verbose:
-        logger.info(f"Found {len(dry_violations)} DRY violation(s)")
+    logger.debug(f"Found {len(dry_violations)} DRY violation(s)")
 
     format_violations(dry_violations, format)
     sys.exit(1 if dry_violations else 0)
@@ -279,8 +272,7 @@ def _execute_magic_numbers_lint(params: ExecuteParams) -> NoReturn:
         orchestrator, params.path_objs, params.recursive, params.parallel
     )
 
-    if params.verbose:
-        logger.info(f"Found {len(magic_numbers_violations)} magic number violation(s)")
+    logger.debug(f"Found {len(magic_numbers_violations)} magic number violation(s)")
 
     format_violations(magic_numbers_violations, params.format)
     sys.exit(1 if magic_numbers_violations else 0)
@@ -325,8 +317,7 @@ def _execute_stringly_typed_lint(params: ExecuteParams) -> NoReturn:
         orchestrator, params.path_objs, params.recursive, params.parallel
     )
 
-    if params.verbose:
-        logger.info(f"Found {len(stringly_violations)} stringly-typed violation(s)")
+    logger.debug(f"Found {len(stringly_violations)} stringly-typed violation(s)")
 
     format_violations(stringly_violations, params.format)
     sys.exit(1 if stringly_violations else 0)

src/cli/linters/documentation.py

@@ -18,11 +18,12 @@ Interfaces: Click CLI commands registered to main CLI group
 Implementation: Click decorators for command definition, orchestrator-based linting execution
 """
 
-import logging
 import sys
 from pathlib import Path
 from typing import TYPE_CHECKING, NoReturn
 
+from loguru import logger
+
 from src.cli.linters.shared import ExecuteParams, create_linter_command
 from src.cli.utils import execute_linting_on_paths, setup_base_orchestrator, validate_paths_exist
 from src.core.cli_utils import format_violations
@@ -31,9 +32,6 @@ from src.core.types import Violation
 if TYPE_CHECKING:
     from src.orchestrator.core import Orchestrator
 
-# Configure module logger
-logger = logging.getLogger(__name__)
-
 
 # =============================================================================
 # File Header Command
@@ -65,8 +63,7 @@ def _execute_file_header_lint(params: ExecuteParams) -> NoReturn:
         orchestrator, params.path_objs, params.recursive, params.parallel
     )
 
-    if params.verbose:
-        logger.info(f"Found {len(file_header_violations)} file header violation(s)")
+    logger.debug(f"Found {len(file_header_violations)} file header violation(s)")
 
     format_violations(file_header_violations, params.format)
     sys.exit(1 if file_header_violations else 0)

src/cli/linters/performance.py

@@ -24,12 +24,12 @@ Suppressions:
       --rule option for 6 total parameters - framework design requirement for CLI extensibility.
 """
 
-import logging
 import sys
 from pathlib import Path
 from typing import TYPE_CHECKING, NoReturn
 
 import click
+from loguru import logger
 
 from src.cli.linters.shared import (
     ExecuteParams,
@@ -46,9 +46,6 @@ from src.core.types import Violation
 if TYPE_CHECKING:
     from src.orchestrator.core import Orchestrator
 
-# Configure module logger
-logger = logging.getLogger(__name__)
-
 
 # =============================================================================
 # String Concat Loop Command
@@ -88,8 +85,7 @@ def _execute_string_concat_lint(params: ExecuteParams) -> NoReturn:
         orchestrator, params.path_objs, params.recursive, params.parallel
     )
 
-    if params.verbose:
-        logger.info(f"Found {len(violations)} string-concat-loop violation(s)")
+    logger.debug(f"Found {len(violations)} string-concat-loop violation(s)")
 
     format_violations(violations, params.format)
     sys.exit(1 if violations else 0)
@@ -124,8 +120,7 @@ def _execute_regex_in_loop_lint(params: ExecuteParams) -> NoReturn:
         orchestrator, params.path_objs, params.recursive, params.parallel
     )
 
-    if params.verbose:
-        logger.info(f"Found {len(violations)} regex-in-loop violation(s)")
+    logger.debug(f"Found {len(violations)} regex-in-loop violation(s)")
 
     format_violations(violations, params.format)
     sys.exit(1 if violations else 0)
@@ -207,8 +202,7 @@ def _execute_perf_lint(params: ExecuteParams, rule: str | None) -> NoReturn:
         orchestrator, params.path_objs, params.recursive, rule, params.parallel
     )
 
-    if params.verbose:
-        logger.info(f"Found {len(violations)} performance violation(s)")
+    logger.debug(f"Found {len(violations)} performance violation(s)")
 
     format_violations(violations, params.format)
     sys.exit(1 if violations else 0)

src/cli/linters/rust.py

@@ -0,0 +1,177 @@
+"""
+Purpose: CLI commands for Rust-specific linters (unwrap-abuse, clone-abuse, blocking-async)
+
+Scope: Commands that detect Rust-specific anti-patterns and code smells
+
+Overview: Provides CLI commands for Rust code linting: unwrap-abuse detects .unwrap() and
+    .expect() calls that may panic at runtime and suggests safer alternatives; clone-abuse
+    detects .clone() abuse patterns including clone in loops, chained clones, and unnecessary
+    clones; blocking-async detects blocking operations (std::fs, std::thread::sleep, std::net)
+    inside async functions and suggests tokio equivalents. Each command supports standard
+    options (config, format, recursive) and integrates with the orchestrator for execution.
+
+Dependencies: click for CLI framework, src.cli.main for CLI group, src.cli.utils for shared utilities
+
+Exports: unwrap_abuse command, clone_abuse command, blocking_async command
+
+Interfaces: Click CLI commands registered to main CLI group
+
+Implementation: Click decorators for command definition, orchestrator-based linting execution
+"""
+
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING, NoReturn
+
+from loguru import logger
+
+from src.cli.linters.shared import ExecuteParams, create_linter_command
+from src.cli.utils import execute_linting_on_paths, setup_base_orchestrator, validate_paths_exist
+from src.core.cli_utils import format_violations
+from src.core.types import Violation
+
+if TYPE_CHECKING:
+    from src.orchestrator.core import Orchestrator
+
+
+# =============================================================================
+# Unwrap Abuse Command
+# =============================================================================
+
+
+def _setup_unwrap_abuse_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+) -> "Orchestrator":
+    """Set up orchestrator for unwrap-abuse command."""
+    return setup_base_orchestrator(path_objs, config_file, verbose, project_root)
+
+
+def _run_unwrap_abuse_lint(
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
+) -> list[Violation]:
+    """Execute unwrap-abuse lint on files or directories."""
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
+    return [v for v in all_violations if v.rule_id.startswith("unwrap-abuse")]
+
+
+def _execute_unwrap_abuse_lint(params: ExecuteParams) -> NoReturn:
+    """Execute unwrap-abuse lint."""
+    validate_paths_exist(params.path_objs)
+    orchestrator = _setup_unwrap_abuse_orchestrator(
+        params.path_objs, params.config_file, params.verbose, params.project_root
+    )
+    unwrap_abuse_violations = _run_unwrap_abuse_lint(
+        orchestrator, params.path_objs, params.recursive, params.parallel
+    )
+
+    logger.debug(f"Found {len(unwrap_abuse_violations)} unwrap abuse violation(s)")
+
+    format_violations(unwrap_abuse_violations, params.format)
+    sys.exit(1 if unwrap_abuse_violations else 0)
+
+
+unwrap_abuse = create_linter_command(
+    "unwrap-abuse",
+    _execute_unwrap_abuse_lint,
+    "Check for .unwrap() and .expect() abuse in Rust code.",
+    "Detects .unwrap() and .expect() calls in Rust code that may panic at runtime.\n"
+    "    Suggests safer alternatives like the ? operator, unwrap_or(),\n"
+    "    unwrap_or_default(), or match/if-let expressions.\n"
+    "    Ignores calls in #[test] functions and #[cfg(test)] modules by default.",
+)
+
+
+# =============================================================================
+# Clone Abuse Command
+# =============================================================================
+
+
+def _setup_clone_abuse_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+) -> "Orchestrator":
+    """Set up orchestrator for clone-abuse command."""
+    return setup_base_orchestrator(path_objs, config_file, verbose, project_root)
+
+
+def _run_clone_abuse_lint(
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
+) -> list[Violation]:
+    """Execute clone-abuse lint on files or directories."""
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
+    return [v for v in all_violations if v.rule_id.startswith("clone-abuse")]
+
+
+def _execute_clone_abuse_lint(params: ExecuteParams) -> NoReturn:
+    """Execute clone-abuse lint."""
+    validate_paths_exist(params.path_objs)
+    orchestrator = _setup_clone_abuse_orchestrator(
+        params.path_objs, params.config_file, params.verbose, params.project_root
+    )
+    clone_abuse_violations = _run_clone_abuse_lint(
+        orchestrator, params.path_objs, params.recursive, params.parallel
+    )
+
+    logger.debug(f"Found {len(clone_abuse_violations)} clone abuse violation(s)")
+
+    format_violations(clone_abuse_violations, params.format)
+    sys.exit(1 if clone_abuse_violations else 0)
+
+
+clone_abuse = create_linter_command(
+    "clone-abuse",
+    _execute_clone_abuse_lint,
+    "Check for .clone() abuse patterns in Rust code.",
+    "Detects .clone() abuse patterns in Rust code: clone in loops,\n"
+    "    chained .clone().clone() calls, and unnecessary clones where\n"
+    "    the original is not used after cloning.\n"
+    "    Suggests borrowing, Rc/Arc, or Cow patterns as alternatives.\n"
+    "    Ignores calls in #[test] functions and #[cfg(test)] modules by default.",
+)
+
+
+# =============================================================================
+# Blocking Async Command
+# =============================================================================
+
+
+def _setup_blocking_async_orchestrator(
+    path_objs: list[Path], config_file: str | None, verbose: bool, project_root: Path | None = None
+) -> "Orchestrator":
+    """Set up orchestrator for blocking-async command."""
+    return setup_base_orchestrator(path_objs, config_file, verbose, project_root)
+
+
+def _run_blocking_async_lint(
+    orchestrator: "Orchestrator", path_objs: list[Path], recursive: bool, parallel: bool = False
+) -> list[Violation]:
+    """Execute blocking-async lint on files or directories."""
+    all_violations = execute_linting_on_paths(orchestrator, path_objs, recursive, parallel)
+    return [v for v in all_violations if v.rule_id.startswith("blocking-async")]
+
+
+def _execute_blocking_async_lint(params: ExecuteParams) -> NoReturn:
+    """Execute blocking-async lint."""
+    validate_paths_exist(params.path_objs)
+    orchestrator = _setup_blocking_async_orchestrator(
+        params.path_objs, params.config_file, params.verbose, params.project_root
+    )
+    blocking_async_violations = _run_blocking_async_lint(
+        orchestrator, params.path_objs, params.recursive, params.parallel
+    )
+
+    logger.debug(f"Found {len(blocking_async_violations)} blocking-async violation(s)")
+
+    format_violations(blocking_async_violations, params.format)
+    sys.exit(1 if blocking_async_violations else 0)
+
+
+blocking_async = create_linter_command(
+    "blocking-async",
+    _execute_blocking_async_lint,
+    "Check for blocking operations in async Rust functions.",
+    "Detects blocking operations inside async functions in Rust code:\n"
+    "    std::fs I/O, std::thread::sleep, and blocking std::net calls.\n"
+    "    Suggests async-compatible alternatives like tokio::fs,\n"
+    "    tokio::time::sleep, and tokio::net equivalents.\n"
+    "    Ignores calls in #[test] functions and #[cfg(test)] modules by default.",
+)

src/cli/linters/shared.py

@@ -27,12 +27,12 @@ Suppressions:
         by Click framework design (ctx, paths, config_file, format, recursive, parallel = 6 params)
 """
 
-import logging
 from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 import click
+from loguru import logger
 
 from src.cli.utils import (
     format_option,
@@ -185,10 +185,6 @@ def run_linter_command(
         handle_linting_error(e, params.verbose)
 
 
-# Configure module logger
-logger = logging.getLogger(__name__)
-
-
 def ensure_config_section(orchestrator: "Orchestrator", section: str) -> dict[str, Any]:
     """Ensure a config section exists and return it.
 
@@ -219,8 +215,7 @@ def set_config_value(config: dict[str, Any], key: str, value: Any, verbose: bool
     if value is None:
         return
     config[key] = value
-    if verbose:
-        logger.debug(f"Overriding {key} to {value}")
+    logger.debug(f"Overriding {key} to {value}")
 
 
 def filter_violations_by_prefix(violations: list[Violation], prefix: str) -> list[Violation]: