thailint 0.1.6__py3-none-any.whl → 0.2.1__py3-none-any.whl

src/cli.py

@@ -11,12 +11,14 @@ Overview: Provides the main CLI application using Click decorators for command d
 
 Dependencies: click for CLI framework, logging for structured output, pathlib for file paths
 
-Exports: cli (main command group), hello command, config command group, file_placement command
+Exports: cli (main command group), hello command, config command group, file_placement command, dry command
 
 Interfaces: Click CLI commands, configuration context via Click ctx, logging integration
 
 Implementation: Click decorators for commands, context passing for shared state, comprehensive help text
 """
+# pylint: disable=too-many-lines
+# Justification: CLI modules naturally have many commands and helper functions
 
 import logging
 import sys
@@ -26,11 +28,20 @@ import click
 
 from src import __version__
 from src.config import ConfigError, load_config, save_config, validate_config
+from src.core.cli_utils import format_violations
 
 # Configure module logger
 logger = logging.getLogger(__name__)
 
 
+# Shared Click option decorators for common CLI options
+def format_option(func):
+    """Add --format option to a command for output format selection."""
+    return click.option(
+        "--format", "-f", type=click.Choice(["text", "json"]), default="text", help="Output format"
+    )(func)
+
+
 def setup_logging(verbose: bool = False):
     """
     Configure logging for the CLI application.
@@ -62,6 +73,10 @@ def cli(ctx, verbose: bool, config: str | None):
 
     Examples:
 
+        \b
+        # Check for duplicate code (DRY violations)
+        thai-lint dry .
+
         \b
         # Lint current directory for file placement issues
         thai-lint file-placement .
@@ -348,16 +363,19 @@ def config_reset(ctx, yes: bool):
 
 
 @cli.command("file-placement")
-@click.argument("path", type=click.Path(exists=True), default=".")
+@click.argument("paths", nargs=-1, type=click.Path())
 @click.option("--config", "-c", "config_file", type=click.Path(), help="Path to config file")
 @click.option("--rules", "-r", help="Inline JSON rules configuration")
-@click.option(
-    "--format", "-f", type=click.Choice(["text", "json"]), default="text", help="Output format"
-)
+@format_option
 @click.option("--recursive/--no-recursive", default=True, help="Scan directories recursively")
 @click.pass_context
 def file_placement(  # pylint: disable=too-many-arguments,too-many-positional-arguments,too-many-locals,too-many-statements
-    ctx, path: str, config_file: str | None, rules: str | None, format: str, recursive: bool
+    ctx,
+    paths: tuple[str, ...],
+    config_file: str | None,
+    rules: str | None,
+    format: str,
+    recursive: bool,
 ):
     # Justification for Pylint disables:
     # - too-many-arguments/positional: CLI requires 1 ctx + 1 arg + 4 options = 6 params
@@ -369,18 +387,26 @@ def file_placement(  # pylint: disable=too-many-arguments,too-many-positional-ar
     Checks that files are placed in appropriate directories according to
     configured rules and patterns.
 
-    PATH: File or directory to lint (defaults to current directory)
+    PATHS: Files or directories to lint (defaults to current directory if none provided)
 
     Examples:
 
         \b
-        # Lint current directory
+        # Lint current directory (all files recursively)
         thai-lint file-placement
 
         \b
         # Lint specific directory
         thai-lint file-placement src/
 
+        \b
+        # Lint single file
+        thai-lint file-placement src/app.py
+
+        \b
+        # Lint multiple files
+        thai-lint file-placement src/app.py src/utils.py tests/test_app.py
+
         \b
         # Use custom config
         thai-lint file-placement --config rules.json .
@@ -390,25 +416,33 @@ def file_placement(  # pylint: disable=too-many-arguments,too-many-positional-ar
         thai-lint file-placement --rules '{"allow": [".*\\.py$"]}' .
     """
     verbose = ctx.obj.get("verbose", False)
-    path_obj = Path(path)
+
+    if not paths:
+        paths = (".",)
+
+    path_objs = [Path(p) for p in paths]
 
     try:
-        _execute_file_placement_lint(path_obj, config_file, rules, format, recursive, verbose)
+        _execute_file_placement_lint(path_objs, config_file, rules, format, recursive, verbose)
     except Exception as e:
         _handle_linting_error(e, verbose)
 
 
 def _execute_file_placement_lint(  # pylint: disable=too-many-arguments,too-many-positional-arguments
-    path_obj, config_file, rules, format, recursive, verbose
+    path_objs, config_file, rules, format, recursive, verbose
 ):
     """Execute file placement linting."""
-    orchestrator = _setup_orchestrator(path_obj, config_file, rules, verbose)
-    violations = _execute_linting(orchestrator, path_obj, recursive)
+    _validate_paths_exist(path_objs)
+    orchestrator = _setup_orchestrator(path_objs, config_file, rules, verbose)
+    all_violations = _execute_linting_on_paths(orchestrator, path_objs, recursive)
+
+    # 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)")
 
-    _output_violations(violations, format)
+    format_violations(violations, format)
     sys.exit(1 if violations else 0)
 
 
@@ -420,11 +454,55 @@ def _handle_linting_error(error: Exception, verbose: bool) -> None:
     sys.exit(2)
 
 
-def _setup_orchestrator(path_obj, config_file, rules, verbose):
+def _validate_paths_exist(path_objs: list[Path]) -> None:
+    """Validate that all provided paths exist.
+
+    Args:
+        path_objs: List of Path objects to validate
+
+    Raises:
+        SystemExit: If any path doesn't exist (exit code 2)
+    """
+    for path in path_objs:
+        if not path.exists():
+            click.echo(f"Error: Path does not exist: {path}", err=True)
+            click.echo("", err=True)
+            click.echo(
+                "Hint: When using Docker, ensure paths are inside the mounted volume:", err=True
+            )
+            click.echo(
+                "  docker run -v $(pwd):/data thailint <command> /data/your-file.py", err=True
+            )
+            sys.exit(2)
+
+
+def _find_project_root(start_path: Path) -> Path:
+    """Find project root by looking for .git or pyproject.toml.
+
+    DEPRECATED: Use src.utils.project_root.get_project_root() instead.
+
+    Args:
+        start_path: Directory to start searching from
+
+    Returns:
+        Path to project root, or start_path if no markers found
+    """
+    from src.utils.project_root import get_project_root
+
+    return get_project_root(start_path)
+
+
+def _setup_orchestrator(path_objs, config_file, rules, verbose):
     """Set up and configure the orchestrator."""
     from src.orchestrator.core import Orchestrator
+    from src.utils.project_root import get_project_root
+
+    # Find actual project root (where .git or pyproject.toml exists)
+    # This ensures .artifacts/ is always created at project root, not in subdirectories
+    first_path = path_objs[0] if path_objs else Path.cwd()
+    search_start = first_path if first_path.is_dir() else first_path.parent
+    project_root = get_project_root(search_start)
 
-    project_root = path_obj if path_obj.is_dir() else path_obj.parent
     orchestrator = Orchestrator(project_root=project_root)
 
     if rules:
@@ -439,7 +517,6 @@ def _apply_inline_rules(orchestrator, rules, verbose):
     """Parse and apply inline JSON rules."""
     rules_config = _parse_json_rules(rules)
     orchestrator.config.update(rules_config)
-    _write_layout_config(orchestrator, rules_config, verbose)
     _log_applied_rules(rules_config, verbose)
 
 
@@ -454,40 +531,6 @@ def _parse_json_rules(rules: str) -> dict:
         sys.exit(2)
 
 
-def _write_layout_config(orchestrator, rules_config: dict, verbose: bool) -> None:
-    """Write layout config to .ai/layout.yaml if possible."""
-    ai_dir = orchestrator.project_root / ".ai"
-    layout_file = ai_dir / "layout.yaml"
-
-    try:
-        _write_layout_yaml_file(ai_dir, layout_file, rules_config)
-        _log_layout_written(layout_file, verbose)
-    except OSError as e:
-        _log_layout_error(e, verbose)
-
-
-def _write_layout_yaml_file(ai_dir, layout_file, rules_config):
-    """Write layout YAML file."""
-    import yaml
-
-    ai_dir.mkdir(exist_ok=True)
-    layout_config = {"file-placement": rules_config}
-    with layout_file.open("w", encoding="utf-8") as f:
-        yaml.dump(layout_config, f)
-
-
-def _log_layout_written(layout_file, verbose):
-    """Log layout file written."""
-    if verbose:
-        logger.debug(f"Written layout config to: {layout_file}")
-
-
-def _log_layout_error(error, verbose):
-    """Log layout write error."""
-    if verbose:
-        logger.debug(f"Could not write layout config: {error}")
-
-
 def _log_applied_rules(rules_config: dict, verbose: bool) -> None:
     """Log applied rules if verbose."""
     if verbose:
@@ -504,98 +547,89 @@ def _load_config_file(orchestrator, config_file, verbose):
     # Load config into orchestrator
     orchestrator.config = orchestrator.config_loader.load(config_path)
 
-    # Also copy to .ai/layout.yaml for file-placement linter
-    _write_loaded_config_to_layout(orchestrator, config_file, verbose)
+    if verbose:
+        logger.debug(f"Loaded config from: {config_file}")
 
 
-def _write_loaded_config_to_layout(orchestrator, config_file: str, verbose: bool) -> None:
-    """Write loaded config to .ai/layout.yaml if possible."""
-    ai_dir = orchestrator.project_root / ".ai"
-    layout_file = ai_dir / "layout.yaml"
+def _execute_linting(orchestrator, path_obj, recursive):
+    """Execute linting on file or directory."""
+    if path_obj.is_file():
+        return orchestrator.lint_file(path_obj)
+    return orchestrator.lint_directory(path_obj, recursive=recursive)
 
-    try:
-        _write_config_yaml(ai_dir, layout_file, orchestrator.config)
-        _log_config_loaded(config_file, layout_file, verbose)
-    except OSError as e:
-        _log_layout_error(e, verbose)
 
+def _separate_files_and_dirs(path_objs: list[Path]) -> tuple[list[Path], list[Path]]:
+    """Separate file paths from directory paths.
 
-def _write_config_yaml(ai_dir, layout_file, config):
-    """Write config to YAML file."""
-    import yaml
+    Args:
+        path_objs: List of Path objects
 
-    ai_dir.mkdir(exist_ok=True)
-    with layout_file.open("w", encoding="utf-8") as f:
-        yaml.dump(config, f)
+    Returns:
+        Tuple of (files, directories)
+    """
+    files = [p for p in path_objs if p.is_file()]
+    dirs = [p for p in path_objs if p.is_dir()]
+    return files, dirs
 
 
-def _log_config_loaded(config_file, layout_file, verbose):
-    """Log config loaded and written."""
-    if verbose:
-        logger.debug(f"Loaded config from: {config_file}")
-        logger.debug(f"Written layout config to: {layout_file}")
+def _lint_files_if_any(orchestrator, files: list[Path]) -> list:
+    """Lint files if list is non-empty.
 
+    Args:
+        orchestrator: Orchestrator instance
+        files: List of file paths
 
-def _execute_linting(orchestrator, path_obj, recursive):
-    """Execute linting on file or directory."""
-    if path_obj.is_file():
-        return orchestrator.lint_file(path_obj)
-    return orchestrator.lint_directory(path_obj, recursive=recursive)
+    Returns:
+        List of violations
+    """
+    if files:
+        return orchestrator.lint_files(files)
+    return []
 
 
-def _output_violations(violations, format):
-    """Format and output violations."""
-    if format == "json":
-        _output_json(violations)
-    else:
-        _output_text(violations)
+def _lint_directories(orchestrator, dirs: list[Path], recursive: bool) -> list:
+    """Lint all directories.
 
+    Args:
+        orchestrator: Orchestrator instance
+        dirs: List of directory paths
+        recursive: Whether to scan recursively
 
-def _output_json(violations):
-    """Output violations in JSON format."""
-    import json
+    Returns:
+        List of violations from all directories
+    """
+    violations = []
+    for dir_path in dirs:
+        violations.extend(orchestrator.lint_directory(dir_path, recursive=recursive))
+    return violations
 
-    output = {
-        "violations": [
-            {
-                "rule_id": v.rule_id,
-                "file_path": str(v.file_path),
-                "line": v.line,
-                "column": v.column,
-                "message": v.message,
-                "severity": v.severity.name,
-            }
-            for v in violations
-        ],
-        "total": len(violations),
-    }
-    click.echo(json.dumps(output, indent=2))
 
+def _execute_linting_on_paths(orchestrator, path_objs: list[Path], recursive: bool) -> list:
+    """Execute linting on list of file/directory paths.
 
-def _output_text(violations):
-    """Output violations in text format."""
-    if not violations:
-        click.echo("✓ No violations found")
-        return
+    Args:
+        orchestrator: Orchestrator instance
+        path_objs: List of Path objects (files or directories)
+        recursive: Whether to scan directories recursively
 
-    click.echo(f"Found {len(violations)} violation(s):\n")
-    for v in violations:
-        _print_violation(v)
+    Returns:
+        List of violations from all paths
+    """
+    files, dirs = _separate_files_and_dirs(path_objs)
 
+    violations = []
+    violations.extend(_lint_files_if_any(orchestrator, files))
+    violations.extend(_lint_directories(orchestrator, dirs, recursive))
 
-def _print_violation(v) -> None:
-    """Print a single violation in text format."""
-    location = f"{v.file_path}:{v.line}" if v.line else str(v.file_path)
-    if v.column:
-        location += f":{v.column}"
-    click.echo(f"  {location}")
-    click.echo(f"    [{v.severity.name}] {v.rule_id}: {v.message}")
-    click.echo()
+    return violations
 
 
-def _setup_nesting_orchestrator(path_obj: Path, config_file: str | None, verbose: bool):
+def _setup_nesting_orchestrator(path_objs: list[Path], config_file: str | None, verbose: bool):
     """Set up orchestrator for nesting command."""
-    project_root = path_obj if path_obj.is_dir() else path_obj.parent
+    # Use first path to determine project root
+    first_path = path_objs[0] if path_objs else Path.cwd()
+    project_root = first_path if first_path.is_dir() else first_path.parent
+
     from src.orchestrator.core import Orchestrator
 
     orchestrator = Orchestrator(project_root=project_root)
@@ -619,45 +653,56 @@ def _apply_nesting_config_override(orchestrator, max_depth: int | None, verbose:
         logger.debug(f"Overriding max_nesting_depth to {max_depth}")
 
 
-def _run_nesting_lint(orchestrator, path_obj: Path, recursive: bool):
-    """Execute nesting lint on file or directory."""
-    if path_obj.is_file():
-        violations = orchestrator.lint_file(path_obj)
-    else:
-        violations = orchestrator.lint_directory(path_obj, recursive=recursive)
-
-    return [v for v in violations if "nesting" in v.rule_id]
+def _run_nesting_lint(orchestrator, path_objs: list[Path], recursive: bool):
+    """Execute nesting lint on files or directories."""
+    all_violations = _execute_linting_on_paths(orchestrator, path_objs, recursive)
+    return [v for v in all_violations if "nesting" in v.rule_id]
 
 
 @cli.command("nesting")
-@click.argument("path", type=click.Path(exists=True), default=".")
+@click.argument("paths", nargs=-1, type=click.Path())
 @click.option("--config", "-c", "config_file", type=click.Path(), help="Path to config file")
-@click.option(
-    "--format", "-f", type=click.Choice(["text", "json"]), default="text", help="Output format"
-)
+@format_option
 @click.option("--max-depth", type=int, help="Override max nesting depth (default: 4)")
 @click.option("--recursive/--no-recursive", default=True, help="Scan directories recursively")
 @click.pass_context
 def nesting(  # pylint: disable=too-many-arguments,too-many-positional-arguments
-    ctx, path: str, config_file: str | None, format: str, max_depth: int | None, recursive: bool
+    ctx,
+    paths: tuple[str, ...],
+    config_file: str | None,
+    format: str,
+    max_depth: int | None,
+    recursive: bool,
 ):
     """Check for excessive nesting depth in code.
 
     Analyzes Python and TypeScript files for deeply nested code structures
     (if/for/while/try statements) and reports violations.
 
-    PATH: File or directory to lint (defaults to current directory)
+    PATHS: Files or directories to lint (defaults to current directory if none provided)
 
     Examples:
 
         \b
-        # Check current directory
+        # Check current directory (all files recursively)
         thai-lint nesting
 
         \b
         # Check specific directory
         thai-lint nesting src/
 
+        \b
+        # Check single file
+        thai-lint nesting src/app.py
+
+        \b
+        # Check multiple files
+        thai-lint nesting src/app.py src/utils.py tests/test_app.py
+
+        \b
+        # Check mix of files and directories
+        thai-lint nesting src/app.py tests/
+
         \b
         # Use custom max depth
         thai-lint nesting --max-depth 3 src/
@@ -671,28 +716,366 @@ def nesting(  # pylint: disable=too-many-arguments,too-many-positional-arguments
         thai-lint nesting --config .thailint.yaml src/
     """
     verbose = ctx.obj.get("verbose", False)
-    path_obj = Path(path)
+
+    # Default to current directory if no paths provided
+    if not paths:
+        paths = (".",)
+
+    path_objs = [Path(p) for p in paths]
 
     try:
-        _execute_nesting_lint(path_obj, config_file, format, max_depth, recursive, verbose)
+        _execute_nesting_lint(path_objs, config_file, format, max_depth, recursive, verbose)
     except Exception as e:
         _handle_linting_error(e, verbose)
 
 
 def _execute_nesting_lint(  # pylint: disable=too-many-arguments,too-many-positional-arguments
-    path_obj, config_file, format, max_depth, recursive, verbose
+    path_objs, config_file, format, max_depth, recursive, verbose
 ):
     """Execute nesting lint."""
-    orchestrator = _setup_nesting_orchestrator(path_obj, config_file, verbose)
+    _validate_paths_exist(path_objs)
+    orchestrator = _setup_nesting_orchestrator(path_objs, config_file, verbose)
     _apply_nesting_config_override(orchestrator, max_depth, verbose)
-    nesting_violations = _run_nesting_lint(orchestrator, path_obj, recursive)
+    nesting_violations = _run_nesting_lint(orchestrator, path_objs, recursive)
 
     if verbose:
         logger.info(f"Found {len(nesting_violations)} nesting violation(s)")
 
-    _output_violations(nesting_violations, format)
+    format_violations(nesting_violations, format)
     sys.exit(1 if nesting_violations else 0)
 
 
+def _setup_srp_orchestrator(path_objs: list[Path], config_file: str | None, verbose: bool):
+    """Set up orchestrator for SRP command."""
+    first_path = path_objs[0] if path_objs else Path.cwd()
+    project_root = first_path if first_path.is_dir() else first_path.parent
+
+    from src.orchestrator.core import Orchestrator
+
+    orchestrator = Orchestrator(project_root=project_root)
+
+    if config_file:
+        _load_config_file(orchestrator, config_file, verbose)
+
+    return orchestrator
+
+
+def _apply_srp_config_override(
+    orchestrator, max_methods: int | None, max_loc: int | None, verbose: bool
+):
+    """Apply max_methods and max_loc overrides to orchestrator config."""
+    if max_methods is None and max_loc is None:
+        return
+
+    if "srp" not in orchestrator.config:
+        orchestrator.config["srp"] = {}
+
+    _apply_srp_max_methods(orchestrator, max_methods, verbose)
+    _apply_srp_max_loc(orchestrator, max_loc, verbose)
+
+
+def _apply_srp_max_methods(orchestrator, max_methods: int | None, verbose: bool):
+    """Apply max_methods override."""
+    if max_methods is not None:
+        orchestrator.config["srp"]["max_methods"] = max_methods
+        if verbose:
+            logger.debug(f"Overriding max_methods to {max_methods}")
+
+
+def _apply_srp_max_loc(orchestrator, max_loc: int | None, verbose: bool):
+    """Apply max_loc override."""
+    if max_loc is not None:
+        orchestrator.config["srp"]["max_loc"] = max_loc
+        if verbose:
+            logger.debug(f"Overriding max_loc to {max_loc}")
+
+
+def _run_srp_lint(orchestrator, path_objs: list[Path], recursive: bool):
+    """Execute SRP lint on files or directories."""
+    all_violations = _execute_linting_on_paths(orchestrator, path_objs, recursive)
+    return [v for v in all_violations if "srp" in v.rule_id]
+
+
+@cli.command("srp")
+@click.argument("paths", nargs=-1, type=click.Path())
+@click.option("--config", "-c", "config_file", type=click.Path(), help="Path to config file")
+@format_option
+@click.option("--max-methods", type=int, help="Override max methods per class (default: 7)")
+@click.option("--max-loc", type=int, help="Override max lines of code per class (default: 200)")
+@click.option("--recursive/--no-recursive", default=True, help="Scan directories recursively")
+@click.pass_context
+def srp(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    ctx,
+    paths: tuple[str, ...],
+    config_file: str | None,
+    format: str,
+    max_methods: int | None,
+    max_loc: int | None,
+    recursive: bool,
+):
+    """Check for Single Responsibility Principle violations.
+
+    Analyzes Python and TypeScript classes for SRP violations using heuristics:
+    - Method count exceeding threshold (default: 7)
+    - Lines of code exceeding threshold (default: 200)
+    - Responsibility keywords in class names (Manager, Handler, Processor, etc.)
+
+    PATHS: Files or directories to lint (defaults to current directory if none provided)
+
+    Examples:
+
+        \b
+        # Check current directory (all files recursively)
+        thai-lint srp
+
+        \b
+        # Check specific directory
+        thai-lint srp src/
+
+        \b
+        # Check single file
+        thai-lint srp src/app.py
+
+        \b
+        # Check multiple files
+        thai-lint srp src/app.py src/service.py tests/test_app.py
+
+        \b
+        # Use custom thresholds
+        thai-lint srp --max-methods 10 --max-loc 300 src/
+
+        \b
+        # Get JSON output
+        thai-lint srp --format json .
+
+        \b
+        # Use custom config file
+        thai-lint srp --config .thailint.yaml src/
+    """
+    verbose = ctx.obj.get("verbose", False)
+
+    if not paths:
+        paths = (".",)
+
+    path_objs = [Path(p) for p in paths]
+
+    try:
+        _execute_srp_lint(path_objs, config_file, format, max_methods, max_loc, recursive, verbose)
+    except Exception as e:
+        _handle_linting_error(e, verbose)
+
+
+def _execute_srp_lint(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    path_objs, config_file, format, max_methods, max_loc, recursive, verbose
+):
+    """Execute SRP lint."""
+    _validate_paths_exist(path_objs)
+    orchestrator = _setup_srp_orchestrator(path_objs, config_file, verbose)
+    _apply_srp_config_override(orchestrator, max_methods, max_loc, verbose)
+    srp_violations = _run_srp_lint(orchestrator, path_objs, recursive)
+
+    if verbose:
+        logger.info(f"Found {len(srp_violations)} SRP violation(s)")
+
+    format_violations(srp_violations, format)
+    sys.exit(1 if srp_violations else 0)
+
+
+@cli.command("dry")
+@click.argument("paths", nargs=-1, type=click.Path())
+@click.option("--config", "-c", "config_file", type=click.Path(), help="Path to config file")
+@format_option
+@click.option("--min-lines", type=int, help="Override min duplicate lines threshold")
+@click.option("--no-cache", is_flag=True, help="Disable SQLite cache (force rehash)")
+@click.option("--clear-cache", is_flag=True, help="Clear cache before running")
+@click.option("--recursive/--no-recursive", default=True, help="Scan directories recursively")
+@click.pass_context
+def dry(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    ctx,
+    paths: tuple[str, ...],
+    config_file: str | None,
+    format: str,
+    min_lines: int | None,
+    no_cache: bool,
+    clear_cache: bool,
+    recursive: bool,
+):
+    # Justification for Pylint disables:
+    # - too-many-arguments/positional: CLI requires 1 ctx + 1 arg + 6 options = 8 params
+    # All parameters are necessary for flexible DRY linter CLI usage.
+    """
+    Check for duplicate code (DRY principle violations).
+
+    Detects duplicate code blocks across your project using token-based hashing
+    with SQLite caching for fast incremental scans.
+
+    PATHS: Files or directories to lint (defaults to current directory if none provided)
+
+    Examples:
+
+        \b
+        # Check current directory (all files recursively)
+        thai-lint dry
+
+        \b
+        # Check specific directory
+        thai-lint dry src/
+
+        \b
+        # Check single file
+        thai-lint dry src/app.py
+
+        \b
+        # Check multiple files
+        thai-lint dry src/app.py src/service.py tests/test_app.py
+
+        \b
+        # Use custom config file
+        thai-lint dry --config .thailint.yaml src/
+
+        \b
+        # Override minimum duplicate lines threshold
+        thai-lint dry --min-lines 5 .
+
+        \b
+        # Disable cache (force re-analysis)
+        thai-lint dry --no-cache .
+
+        \b
+        # Clear cache before running
+        thai-lint dry --clear-cache .
+
+        \b
+        # Get JSON output
+        thai-lint dry --format json .
+    """
+    verbose = ctx.obj.get("verbose", False)
+
+    if not paths:
+        paths = (".",)
+
+    path_objs = [Path(p) for p in paths]
+
+    try:
+        _execute_dry_lint(
+            path_objs, config_file, format, min_lines, no_cache, clear_cache, recursive, verbose
+        )
+    except Exception as e:
+        _handle_linting_error(e, verbose)
+
+
+def _execute_dry_lint(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    path_objs, config_file, format, min_lines, no_cache, clear_cache, recursive, verbose
+):
+    """Execute DRY linting."""
+    _validate_paths_exist(path_objs)
+    orchestrator = _setup_dry_orchestrator(path_objs, config_file, verbose)
+    _apply_dry_config_override(orchestrator, min_lines, no_cache, verbose)
+
+    if clear_cache:
+        _clear_dry_cache(orchestrator, verbose)
+
+    dry_violations = _run_dry_lint(orchestrator, path_objs, recursive)
+
+    if verbose:
+        logger.info(f"Found {len(dry_violations)} DRY violation(s)")
+
+    format_violations(dry_violations, format)
+    sys.exit(1 if dry_violations else 0)
+
+
+def _setup_dry_orchestrator(path_objs, config_file, verbose):
+    """Set up orchestrator for DRY linting."""
+    from src.orchestrator.core import Orchestrator
+    from src.utils.project_root import get_project_root
+
+    first_path = path_objs[0] if path_objs else Path.cwd()
+    search_start = first_path if first_path.is_dir() else first_path.parent
+    project_root = get_project_root(search_start)
+
+    orchestrator = Orchestrator(project_root=project_root)
+
+    if config_file:
+        _load_dry_config_file(orchestrator, config_file, verbose)
+
+    return orchestrator
+
+
+def _load_dry_config_file(orchestrator, config_file, verbose):
+    """Load DRY configuration from file."""
+    import yaml
+
+    config_path = Path(config_file)
+    if not config_path.exists():
+        click.echo(f"Error: Config file not found: {config_file}", err=True)
+        sys.exit(2)
+
+    with config_path.open("r", encoding="utf-8") as f:
+        config = yaml.safe_load(f)
+
+    if "dry" in config:
+        orchestrator.config.update({"dry": config["dry"]})
+
+        if verbose:
+            logger.info(f"Loaded DRY config from {config_file}")
+
+
+def _apply_dry_config_override(orchestrator, min_lines, no_cache, verbose):
+    """Apply CLI option overrides to DRY config."""
+    _ensure_dry_config_exists(orchestrator)
+    _apply_min_lines_override(orchestrator, min_lines, verbose)
+    _apply_cache_override(orchestrator, no_cache, verbose)
+
+
+def _ensure_dry_config_exists(orchestrator):
+    """Ensure dry config section exists."""
+    if "dry" not in orchestrator.config:
+        orchestrator.config["dry"] = {}
+
+
+def _apply_min_lines_override(orchestrator, min_lines, verbose):
+    """Apply min_lines override if provided."""
+    if min_lines is None:
+        return
+
+    orchestrator.config["dry"]["min_duplicate_lines"] = min_lines
+    if verbose:
+        logger.info(f"Override: min_duplicate_lines = {min_lines}")
+
+
+def _apply_cache_override(orchestrator, no_cache, verbose):
+    """Apply cache override if requested."""
+    if not no_cache:
+        return
+
+    orchestrator.config["dry"]["cache_enabled"] = False
+    if verbose:
+        logger.info("Override: cache_enabled = False")
+
+
+def _clear_dry_cache(orchestrator, verbose):
+    """Clear DRY cache before running."""
+    cache_path_str = orchestrator.config.get("dry", {}).get("cache_path", ".thailint-cache/dry.db")
+    cache_path = orchestrator.project_root / cache_path_str
+
+    if cache_path.exists():
+        cache_path.unlink()
+        if verbose:
+            logger.info(f"Cleared cache: {cache_path}")
+    else:
+        if verbose:
+            logger.info("Cache file does not exist, nothing to clear")
+
+
+def _run_dry_lint(orchestrator, path_objs, recursive):
+    """Run DRY linting and return violations."""
+    all_violations = _execute_linting_on_paths(orchestrator, path_objs, recursive)
+
+    # Filter to only DRY violations
+    dry_violations = [v for v in all_violations if v.rule_id.startswith("dry.")]
+
+    return dry_violations
+
+
 if __name__ == "__main__":
     cli()