lintro 0.13.2__py3-none-any.whl → 0.17.2__py3-none-any.whl

lintro/tools/implementations/tool_prettier.py

@@ -1,12 +1,14 @@
 """Prettier code formatter integration."""
 
 import os
+import subprocess  # nosec B404 - used safely with shell disabled
 from dataclasses import dataclass, field
 
 from loguru import logger
 
 from lintro.enums.tool_type import ToolType
 from lintro.models.core.tool import Tool, ToolConfig, ToolResult
+from lintro.parsers.prettier.prettier_issue import PrettierIssue
 from lintro.parsers.prettier.prettier_parser import parse_prettier_output
 from lintro.tools.core.tool_base import BaseTool
 from lintro.utils.tool_utils import walk_files_with_excludes
@@ -55,12 +57,21 @@ class PrettierTool(BaseTool):
         ),
     )
 
+    def __post_init__(self) -> None:
+        """Initialize prettier tool."""
+        super().__post_init__()
+        # Note: .prettierignore is handled by passing --ignore-path to prettier
+        # rather than loading into lintro's exclude patterns, to ensure prettier's
+        # native ignore logic is used consistently
+
     def set_options(
         self,
         exclude_patterns: list[str] | None = None,
         include_venv: bool = False,
         timeout: int | None = None,
         verbose_fix_output: bool | None = None,
+        line_length: int | None = None,
+        **kwargs,
     ) -> None:
         """Set options for the core.
 
@@ -69,13 +80,26 @@ class PrettierTool(BaseTool):
             include_venv: Whether to include virtual environment directories
             timeout: Timeout in seconds per file (default: 30)
             verbose_fix_output: If True, include raw Prettier output in fix()
+            line_length: Print width for prettier (maps to --print-width).
+                If provided, this will be stored and used in CLI args.
+            **kwargs: Additional options (ignored for compatibility)
+
+        Raises:
+            ValueError: If line_length is not a positive integer.
         """
-        self.exclude_patterns = exclude_patterns or []
+        if exclude_patterns is not None:
+            self.exclude_patterns = exclude_patterns.copy()
         self.include_venv = include_venv
         if timeout is not None:
             self.timeout = timeout
         if verbose_fix_output is not None:
             self.options["verbose_fix_output"] = verbose_fix_output
+        if line_length is not None:
+            if not isinstance(line_length, int):
+                raise ValueError("line_length must be an integer")
+            if line_length <= 0:
+                raise ValueError("line_length must be positive")
+            self.options["line_length"] = line_length
 
     def _find_config(self) -> str | None:
         """Locate a Prettier config if none is found by native discovery.
@@ -90,6 +114,150 @@ class PrettierTool(BaseTool):
         """
         return None
 
+    def _find_prettier_config(self, search_dir: str | None = None) -> str | None:
+        """Locate prettier config file by walking up the directory tree.
+
+        Prettier searches upward from the file's directory to find config files,
+        so we do the same to match native behavior and ensure config is found
+        even when cwd is a subdirectory.
+
+        Args:
+            search_dir: Directory to start searching from. If None, searches from
+                current working directory.
+
+        Returns:
+            str | None: Path to config file if found, None otherwise.
+        """
+        config_paths = [
+            ".prettierrc",
+            ".prettierrc.json",
+            ".prettierrc.js",
+            ".prettierrc.yaml",
+            ".prettierrc.yml",
+            "prettier.config.js",
+            "package.json",
+        ]
+        # Search upward from search_dir (or cwd) to find config, just like prettier does
+        start_dir = os.path.abspath(search_dir) if search_dir else os.getcwd()
+        current_dir = start_dir
+
+        # Walk upward from the directory to find config
+        # Stop at filesystem root to avoid infinite loop
+        while True:
+            for config_name in config_paths:
+                config_path = os.path.join(current_dir, config_name)
+                if os.path.exists(config_path):
+                    # For package.json, check if it contains prettier config
+                    if config_name == "package.json":
+                        try:
+                            import json
+
+                            with open(config_path, encoding="utf-8") as f:
+                                pkg_data = json.load(f)
+                                if "prettier" not in pkg_data:
+                                    continue
+                        except (
+                            json.JSONDecodeError,
+                            FileNotFoundError,
+                            PermissionError,
+                        ):
+                            # Skip invalid or unreadable package.json files
+                            continue
+                    logger.debug(
+                        f"[PrettierTool] Found config file: {config_path} "
+                        f"(searched from {start_dir})",
+                    )
+                    return config_path
+
+            # Move up one directory
+            parent_dir = os.path.dirname(current_dir)
+            # Stop if we've reached the filesystem root (parent == current)
+            if parent_dir == current_dir:
+                break
+            current_dir = parent_dir
+
+        return None
+
+    def _find_prettierignore(self, search_dir: str | None = None) -> str | None:
+        """Locate .prettierignore file by walking up the directory tree.
+
+        Prettier searches upward from the file's directory to find .prettierignore,
+        so we do the same to match native behavior and ensure ignore file is found
+        even when cwd is a subdirectory.
+
+        Args:
+            search_dir: Directory to start searching from. If None, searches from
+                current working directory.
+
+        Returns:
+            str | None: Path to .prettierignore file if found, None otherwise.
+        """
+        ignore_filename = ".prettierignore"
+        # Search upward from search_dir (or cwd) to find ignore file
+        start_dir = os.path.abspath(search_dir) if search_dir else os.getcwd()
+        current_dir = start_dir
+
+        # Walk upward from the directory to find ignore file
+        # Stop at filesystem root to avoid infinite loop
+        while True:
+            ignore_path = os.path.join(current_dir, ignore_filename)
+            if os.path.exists(ignore_path):
+                logger.debug(
+                    f"[PrettierTool] Found .prettierignore: {ignore_path} "
+                    f"(searched from {start_dir})",
+                )
+                return ignore_path
+
+            # Move up one directory
+            parent_dir = os.path.dirname(current_dir)
+            # Stop if we've reached the filesystem root (parent == current)
+            if parent_dir == current_dir:
+                break
+            current_dir = parent_dir
+
+        return None
+
+    def _create_timeout_result(
+        self,
+        timeout_val: int,
+        initial_issues: list | None = None,
+        initial_count: int = 0,
+    ) -> ToolResult:
+        """Create a ToolResult for timeout scenarios.
+
+        Args:
+            timeout_val: The timeout value that was exceeded.
+            initial_issues: Optional list of issues found before timeout.
+            initial_count: Optional count of initial issues.
+
+        Returns:
+            ToolResult: ToolResult instance representing timeout failure.
+        """
+        timeout_msg = (
+            f"Prettier execution timed out ({timeout_val}s limit exceeded).\n\n"
+            "This may indicate:\n"
+            "  - Large codebase taking too long to process\n"
+            "  - Need to increase timeout via --tool-options prettier:timeout=N"
+        )
+        timeout_issue = PrettierIssue(
+            file="execution",
+            line=None,
+            code="TIMEOUT",
+            message=timeout_msg,
+            column=None,
+        )
+        combined_issues = (initial_issues or []) + [timeout_issue]
+        return ToolResult(
+            name=self.name,
+            success=False,
+            output=timeout_msg,
+            issues_count=len(combined_issues),
+            issues=combined_issues,
+            initial_issues_count=initial_count,
+            fixed_issues_count=0,
+            remaining_issues_count=len(combined_issues),
+        )
+
     def check(
         self,
         paths: list[str],
@@ -102,6 +270,11 @@ class PrettierTool(BaseTool):
         Returns:
             ToolResult instance
         """
+        # Check version requirements
+        version_result = self._verify_tool_version()
+        if version_result is not None:
+            return version_result
+
         self._validate_paths(paths=paths)
         prettier_files: list[str] = walk_files_with_excludes(
             paths=paths,
@@ -109,6 +282,17 @@ class PrettierTool(BaseTool):
             exclude_patterns=self.exclude_patterns,
             include_venv=self.include_venv,
         )
+        logger.debug(
+            f"[PrettierTool] Discovered {len(prettier_files)} files matching patterns: "
+            f"{self.config.file_patterns}",
+        )
+        logger.debug(
+            f"[PrettierTool] Exclude patterns applied: {self.exclude_patterns}",
+        )
+        if prettier_files:
+            logger.debug(
+                f"[PrettierTool] Files to check (first 10): " f"{prettier_files[:10]}",
+            )
         if not prettier_files:
             return Tool.to_result(
                 name=self.name,
@@ -118,6 +302,7 @@ class PrettierTool(BaseTool):
             )
         # Use relative paths and set cwd to the common parent
         cwd: str = self.get_cwd(paths=prettier_files)
+        logger.debug(f"[PrettierTool] Working directory: {cwd}")
         rel_files: list[str] = [
             os.path.relpath(f, cwd) if cwd else f for f in prettier_files
         ]
@@ -125,14 +310,53 @@ class PrettierTool(BaseTool):
         cmd: list[str] = self._get_executable_command(tool_name="prettier") + [
             "--check",
         ]
-        # Do not force config; rely on native discovery via cwd
+
+        # Add Lintro config injection args (--no-config, --config)
+        # This takes precedence over native config auto-discovery
+        config_args = self._build_config_args()
+        if config_args:
+            cmd.extend(config_args)
+            logger.debug(
+                "[PrettierTool] Using Lintro config injection",
+            )
+        else:
+            # Fallback: Find config and ignore files by walking up from cwd
+            found_config = self._find_prettier_config(search_dir=cwd)
+            if found_config:
+                logger.debug(
+                    f"[PrettierTool] Found config: {found_config} (auto-detecting)",
+                )
+            else:
+                logger.debug(
+                    "[PrettierTool] No prettier config file found (using defaults)",
+                )
+                # Apply line_length as --print-width if set and no config found
+                line_length = self.options.get("line_length")
+                if line_length:
+                    cmd.extend(["--print-width", str(line_length)])
+                    logger.debug(
+                        "[PrettierTool] Using --print-width=%s from options",
+                        line_length,
+                    )
+            # Find .prettierignore by walking up from cwd
+            prettierignore_path = self._find_prettierignore(search_dir=cwd)
+            if prettierignore_path:
+                logger.debug(
+                    f"[PrettierTool] Found .prettierignore: {prettierignore_path} "
+                    "(auto-detecting)",
+                )
+
         cmd.extend(rel_files)
         logger.debug(f"[PrettierTool] Running: {' '.join(cmd)} (cwd={cwd})")
-        result = self._run_subprocess(
-            cmd=cmd,
-            timeout=self.options.get("timeout", self._default_timeout),
-            cwd=cwd,
-        )
+        timeout_val: int = self.options.get("timeout", self._default_timeout)
+        try:
+            result = self._run_subprocess(
+                cmd=cmd,
+                timeout=timeout_val,
+                cwd=cwd,
+            )
+        except subprocess.TimeoutExpired:
+            return self._create_timeout_result(timeout_val=timeout_val)
         output: str = result[1]
         # Do not filter lines post-hoc; rely on discovery and ignore files
         issues: list = parse_prettier_output(output=output)
@@ -164,6 +388,11 @@ class PrettierTool(BaseTool):
         Returns:
             ToolResult: Result object with counts and messages.
         """
+        # Check version requirements
+        version_result = self._verify_tool_version()
+        if version_result is not None:
+            return version_result
+
         self._validate_paths(paths=paths)
         prettier_files: list[str] = walk_files_with_excludes(
             paths=paths,
@@ -185,18 +414,55 @@ class PrettierTool(BaseTool):
             os.path.relpath(f, cwd) if cwd else f for f in prettier_files
         ]
 
+        # Get Lintro config injection args (--no-config, --config)
+        config_args = self._build_config_args()
+        fallback_args: list[str] = []
+        if not config_args:
+            # Fallback: Find config and ignore files by walking up from cwd
+            found_config = self._find_prettier_config(search_dir=cwd)
+            if found_config:
+                logger.debug(
+                    f"[PrettierTool] Found config: {found_config} (auto-detecting)",
+                )
+            else:
+                logger.debug(
+                    "[PrettierTool] No prettier config file found (using defaults)",
+                )
+                # Apply line_length as --print-width if set and no config found
+                line_length = self.options.get("line_length")
+                if line_length:
+                    fallback_args.extend(["--print-width", str(line_length)])
+                    logger.debug(
+                        "[PrettierTool] Using --print-width=%s from options",
+                        line_length,
+                    )
+            prettierignore_path = self._find_prettierignore(search_dir=cwd)
+            if prettierignore_path:
+                logger.debug(
+                    f"[PrettierTool] Found .prettierignore: {prettierignore_path} "
+                    "(auto-detecting)",
+                )
+
         # Check for issues first
         check_cmd: list[str] = self._get_executable_command(tool_name="prettier") + [
             "--check",
         ]
-        # Do not force config; rely on native discovery via cwd
+        # Add Lintro config injection if available, otherwise use fallback args
+        if config_args:
+            check_cmd.extend(config_args)
+        elif fallback_args:
+            check_cmd.extend(fallback_args)
         check_cmd.extend(rel_files)
         logger.debug(f"[PrettierTool] Checking: {' '.join(check_cmd)} (cwd={cwd})")
-        check_result = self._run_subprocess(
-            cmd=check_cmd,
-            timeout=self.options.get("timeout", self._default_timeout),
-            cwd=cwd,
-        )
+        timeout_val: int = self.options.get("timeout", self._default_timeout)
+        try:
+            check_result = self._run_subprocess(
+                cmd=check_cmd,
+                timeout=timeout_val,
+                cwd=cwd,
+            )
+        except subprocess.TimeoutExpired:
+            return self._create_timeout_result(timeout_val=timeout_val)
         check_output: str = check_result[1]
 
         # Parse initial issues
@@ -207,21 +473,40 @@ class PrettierTool(BaseTool):
         fix_cmd: list[str] = self._get_executable_command(tool_name="prettier") + [
             "--write",
         ]
+        # Add Lintro config injection if available, otherwise use fallback args
+        if config_args:
+            fix_cmd.extend(config_args)
+        elif fallback_args:
+            fix_cmd.extend(fallback_args)
         fix_cmd.extend(rel_files)
         logger.debug(f"[PrettierTool] Fixing: {' '.join(fix_cmd)} (cwd={cwd})")
-        fix_result = self._run_subprocess(
-            cmd=fix_cmd,
-            timeout=self.options.get("timeout", self._default_timeout),
-            cwd=cwd,
-        )
+        try:
+            fix_result = self._run_subprocess(
+                cmd=fix_cmd,
+                timeout=timeout_val,
+                cwd=cwd,
+            )
+        except subprocess.TimeoutExpired:
+            return self._create_timeout_result(
+                timeout_val=timeout_val,
+                initial_issues=initial_issues,
+                initial_count=initial_count,
+            )
         fix_output: str = fix_result[1]
 
         # Check for remaining issues after fixing
-        final_check_result = self._run_subprocess(
-            cmd=check_cmd,
-            timeout=self.options.get("timeout", self._default_timeout),
-            cwd=cwd,
-        )
+        try:
+            final_check_result = self._run_subprocess(
+                cmd=check_cmd,
+                timeout=timeout_val,
+                cwd=cwd,
+            )
+        except subprocess.TimeoutExpired:
+            return self._create_timeout_result(
+                timeout_val=timeout_val,
+                initial_issues=initial_issues,
+                initial_count=initial_count,
+            )
         final_check_output: str = final_check_result[1]
         remaining_issues: list = parse_prettier_output(output=final_check_output)
         remaining_count: int = len(remaining_issues)
@@ -261,15 +546,17 @@ class PrettierTool(BaseTool):
         # Success means no remaining issues
         success: bool = remaining_count == 0
 
+        # Combine initial and remaining issues so formatter can split them by fixability
+        all_issues = (initial_issues or []) + (remaining_issues or [])
+
         return ToolResult(
             name=self.name,
             success=success,
             output=final_output,
             # For fix operations, issues_count represents remaining for summaries
             issues_count=remaining_count,
-            # Provide issues so formatters can render tables. Use initial issues
-            # (auto-fixable set) for display; fall back to remaining when none.
-            issues=(initial_issues if initial_issues else remaining_issues),
+            # Provide both initial (fixed) and remaining issues for display
+            issues=all_issues,
             initial_issues_count=initial_count,
             fixed_issues_count=fixed_count,
             remaining_issues_count=remaining_count,