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

lintro/tools/implementations/tool_darglint.py

@@ -3,6 +3,7 @@
 import subprocess  # nosec B404 - vetted use via BaseTool._run_subprocess
 from dataclasses import dataclass, field
 
+import click
 from loguru import logger
 
 from lintro.enums.darglint_strictness import (
@@ -11,12 +12,14 @@ from lintro.enums.darglint_strictness import (
 )
 from lintro.enums.tool_type import ToolType
 from lintro.models.core.tool import ToolConfig, ToolResult
+from lintro.parsers.darglint.darglint_issue import DarglintIssue
 from lintro.parsers.darglint.darglint_parser import parse_darglint_output
 from lintro.tools.core.tool_base import BaseTool
 from lintro.utils.tool_utils import walk_files_with_excludes
 
 # Constants for Darglint configuration
-DARGLINT_DEFAULT_TIMEOUT: int = 30
+# Increased from 30 to handle large files with complex docstrings
+DARGLINT_DEFAULT_TIMEOUT: int = 60
 DARGLINT_DEFAULT_PRIORITY: int = 45
 DARGLINT_FILE_PATTERNS: list[str] = ["*.py"]
 DARGLINT_STRICTNESS_LEVELS: tuple[str, ...] = tuple(
@@ -28,6 +31,25 @@ DARGLINT_DEFAULT_VERBOSITY: int = 2
 DARGLINT_DEFAULT_STRICTNESS: str = "full"
 
 
+@dataclass
+class FileProcessResult:
+    """Result of processing a single file with Darglint.
+
+    Attributes:
+        success: Whether the file was processed successfully.
+        issues_count: Number of issues found.
+        issues: List of parsed issues.
+        output: Raw output from the tool, or None if no output.
+        timeout_issue: Timeout issue if a timeout occurred, or None.
+    """
+
+    success: bool
+    issues_count: int
+    issues: list[DarglintIssue]
+    output: str | None
+    timeout_issue: DarglintIssue | None
+
+
 @dataclass
 class DarglintTool(BaseTool):
     """Darglint docstring linter integration.
@@ -157,6 +179,66 @@ class DarglintTool(BaseTool):
 
         return cmd
 
+    def _process_file(
+        self,
+        file_path: str,
+        timeout: int,
+    ) -> FileProcessResult:
+        """Process a single file with Darglint.
+
+        Args:
+            file_path: Path to the file to process.
+            timeout: Timeout in seconds for the subprocess execution.
+
+        Returns:
+            FileProcessResult: Result containing success status, issues, and output.
+        """
+        cmd: list[str] = self._build_command() + [str(file_path)]
+        try:
+            success: bool
+            output: str
+            success, output = self._run_subprocess(cmd=cmd, timeout=timeout)
+            issues = parse_darglint_output(output=output)
+            issues_count: int = len(issues)
+            return FileProcessResult(
+                success=success and issues_count == 0,
+                issues_count=issues_count,
+                issues=issues,
+                output=output,
+                timeout_issue=None,
+            )
+        except subprocess.TimeoutExpired:
+            # Create a timeout issue object to display in the table
+            timeout_issue = DarglintIssue(
+                file=str(file_path),
+                line=0,
+                code="TIMEOUT",
+                message=(
+                    f"Darglint execution timed out "
+                    f"({timeout}s limit exceeded). "
+                    "This may indicate:\n"
+                    "  - Large file taking too long to analyze\n"
+                    "  - Complex docstrings requiring extensive parsing\n"
+                    "  - Need to increase timeout via "
+                    "--tool-options darglint:timeout=N"
+                ),
+            )
+            return FileProcessResult(
+                success=False,
+                issues_count=0,
+                issues=[],
+                output=None,
+                timeout_issue=timeout_issue,
+            )
+        except Exception as e:
+            return FileProcessResult(
+                success=False,
+                issues_count=0,
+                issues=[],
+                output=f"Error processing {file_path}: {str(e)}",
+                timeout_issue=None,
+            )
+
     def check(
         self,
         paths: list[str],
@@ -169,6 +251,11 @@ class DarglintTool(BaseTool):
         Returns:
             ToolResult: 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)
         if not paths:
             return ToolResult(
@@ -189,44 +276,116 @@ class DarglintTool(BaseTool):
 
         timeout: int = self.options.get("timeout", DARGLINT_DEFAULT_TIMEOUT)
         all_outputs: list[str] = []
+        all_issues: list[DarglintIssue] = []
         all_success: bool = True
         skipped_files: list[str] = []
+        execution_failures: int = 0
         total_issues: int = 0
 
-        for file_path in python_files:
-            cmd: list[str] = self._build_command() + [str(file_path)]
-            try:
-                success: bool
-                output: str
-                success, output = self._run_subprocess(cmd=cmd, timeout=timeout)
-                issues = parse_darglint_output(output=output)
-                issues_count: int = len(issues)
-                if not (success and issues_count == 0):
+        # Show progress bar only when processing multiple files
+        if len(python_files) >= 2:
+            with click.progressbar(
+                python_files,
+                label="Processing files",
+                bar_template="%(label)s  %(info)s",
+            ) as bar:
+                for file_path in bar:
+                    result = self._process_file(file_path=file_path, timeout=timeout)
+                    if not result.success:
+                        all_success = False
+                    total_issues += result.issues_count
+                    if result.issues:
+                        all_issues.extend(result.issues)
+                    if result.output:
+                        all_outputs.append(result.output)
+                    if result.timeout_issue:
+                        skipped_files.append(file_path)
+                        execution_failures += 1
+                        all_issues.append(result.timeout_issue)
+                    elif (
+                        not result.success
+                        and not result.timeout_issue
+                        and result.issues_count == 0
+                        and result.output
+                        and "Error" in result.output
+                    ):
+                        # Only count as execution failure if no lint issues were found
+                        # and there's an actual error (not just lint findings)
+                        execution_failures += 1
+                        # Create an execution error issue to keep issues consistent
+                        # with issues_count
+                        error_issue = DarglintIssue(
+                            file=str(file_path),
+                            line=0,
+                            code="EXEC_ERROR",
+                            message=(
+                                f"Execution error: {result.output.strip()}"
+                                if result.output
+                                else "Execution error during darglint processing"
+                            ),
+                        )
+                        all_issues.append(error_issue)
+        else:
+            # Process without progress bar for single file or no files
+            for file_path in python_files:
+                result = self._process_file(file_path=file_path, timeout=timeout)
+                if not result.success:
                     all_success = False
-                total_issues += issues_count
-                # Store parsed issues on the aggregate result later via ToolResult
-                all_outputs.append(output)
-            except subprocess.TimeoutExpired:
-                skipped_files.append(file_path)
-                all_success = False
-            except Exception as e:
-                all_outputs.append(f"Error processing {file_path}: {str(e)}")
-                all_success = False
+                total_issues += result.issues_count
+                if result.issues:
+                    all_issues.extend(result.issues)
+                if result.output:
+                    all_outputs.append(result.output)
+                if result.timeout_issue:
+                    skipped_files.append(file_path)
+                    execution_failures += 1
+                    all_issues.append(result.timeout_issue)
+                elif (
+                    not result.success
+                    and not result.timeout_issue
+                    and result.issues_count == 0
+                    and result.output
+                    and "Error" in result.output
+                ):
+                    # Only count as execution failure if no lint issues were found
+                    # and there's an actual error (not just lint findings)
+                    execution_failures += 1
+                    # Create an execution error issue to keep issues consistent
+                    # with issues_count
+                    error_issue = DarglintIssue(
+                        file=str(file_path),
+                        line=0,
+                        code="EXEC_ERROR",
+                        message=(
+                            f"Execution error: {result.output.strip()}"
+                            if result.output
+                            else "Execution error during darglint processing"
+                        ),
+                    )
+                    all_issues.append(error_issue)
 
         output: str = "\n".join(all_outputs)
         if skipped_files:
-            output += f"\n\nSkipped {len(skipped_files)} files due to timeout:"
+            output += (
+                f"\n\nSkipped {len(skipped_files)} file(s) due to timeout "
+                f"({timeout}s limit exceeded):"
+            )
             for file in skipped_files:
                 output += f"\n  - {file}"
 
         if not output:
             output = None
 
+        # Include execution failures (timeouts/errors) in issues_count
+        # to properly reflect tool failure status
+        total_issues_with_failures = total_issues + execution_failures
+
         return ToolResult(
             name=self.name,
             success=all_success,
             output=output,
-            issues_count=total_issues,
+            issues_count=total_issues_with_failures,
+            issues=all_issues,
         )
 
     def fix(

lintro/tools/implementations/tool_eslint.py

@@ -0,0 +1,374 @@
+"""ESLint linter 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.eslint.eslint_issue import EslintIssue
+from lintro.parsers.eslint.eslint_parser import parse_eslint_output
+from lintro.tools.core.tool_base import BaseTool
+from lintro.utils.tool_utils import walk_files_with_excludes
+
+# Constants for ESLint configuration
+ESLINT_DEFAULT_TIMEOUT: int = 30
+ESLINT_DEFAULT_PRIORITY: int = 50  # Lower priority than formatters
+ESLINT_FILE_PATTERNS: list[str] = [
+    "*.js",
+    "*.jsx",
+    "*.ts",
+    "*.tsx",
+    "*.mjs",
+    "*.cjs",
+]
+
+
+@dataclass
+class EslintTool(BaseTool):
+    """ESLint linter integration.
+
+    A linter for JavaScript and TypeScript that identifies problems in code.
+    """
+
+    name: str = "eslint"
+    description: str = (
+        "Linter for JavaScript and TypeScript that identifies and reports "
+        "on patterns in code"
+    )
+    can_fix: bool = True
+    config: ToolConfig = field(
+        default_factory=lambda: ToolConfig(
+            priority=ESLINT_DEFAULT_PRIORITY,  # Lower priority than formatters
+            conflicts_with=[],  # No direct conflicts
+            file_patterns=ESLINT_FILE_PATTERNS,
+            tool_type=ToolType.LINTER,
+        ),
+    )
+
+    def __post_init__(self) -> None:
+        """Initialize eslint tool."""
+        super().__post_init__()
+        # Note: .eslintignore is handled natively by ESLint
+        # ESLint config files (.eslintrc.*, eslint.config.*) are also
+        # discovered natively
+
+    def set_options(
+        self,
+        exclude_patterns: list[str] | None = None,
+        include_venv: bool = False,
+        timeout: int | None = None,
+        verbose_fix_output: bool | None = None,
+        **kwargs,
+    ) -> None:
+        """Set options for the core.
+
+        Args:
+            exclude_patterns: List of patterns to exclude
+            include_venv: Whether to include virtual environment directories
+            timeout: Timeout in seconds per file (default: 30)
+            verbose_fix_output: If True, include raw ESLint output in fix()
+            **kwargs: Additional options (ignored for compatibility)
+        """
+        if exclude_patterns is not None:
+            self.exclude_patterns = exclude_patterns.copy()
+        self.include_venv = include_venv
+        if timeout is not None:
+            self.options["timeout"] = timeout
+        if verbose_fix_output is not None:
+            self.options["verbose_fix_output"] = verbose_fix_output
+
+    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"ESLint 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 eslint:timeout=N"
+        )
+        timeout_issue = EslintIssue(
+            file="execution",
+            line=1,
+            code="TIMEOUT",
+            message=timeout_msg,
+            column=1,
+            severity=2,
+            fixable=False,
+        )
+        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],
+    ) -> ToolResult:
+        """Check files with ESLint without making changes.
+
+        Args:
+            paths: List of file or directory paths to check
+
+        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)
+        eslint_files: list[str] = walk_files_with_excludes(
+            paths=paths,
+            file_patterns=self.config.file_patterns,
+            exclude_patterns=self.exclude_patterns,
+            include_venv=self.include_venv,
+        )
+        logger.debug(
+            f"[EslintTool] Discovered {len(eslint_files)} files matching patterns: "
+            f"{self.config.file_patterns}",
+        )
+        logger.debug(
+            f"[EslintTool] Exclude patterns applied: {self.exclude_patterns}",
+        )
+        if eslint_files:
+            logger.debug(
+                f"[EslintTool] Files to check (first 10): " f"{eslint_files[:10]}",
+            )
+        if not eslint_files:
+            return Tool.to_result(
+                name=self.name,
+                success=True,
+                output="No files to check.",
+                issues_count=0,
+            )
+
+        # Use relative paths and set cwd to the common parent
+        cwd: str = self.get_cwd(paths=eslint_files)
+        logger.debug(f"[EslintTool] Working directory: {cwd}")
+        rel_files: list[str] = [
+            os.path.relpath(f, cwd) if cwd else f for f in eslint_files
+        ]
+
+        # Build ESLint command with JSON output format
+        cmd: list[str] = self._get_executable_command(tool_name="eslint") + [
+            "--format",
+            "json",
+        ]
+
+        # Add Lintro config injection args if available
+        config_args = self._build_config_args()
+        if config_args:
+            cmd.extend(config_args)
+            logger.debug(
+                "[EslintTool] Using Lintro config injection",
+            )
+
+        cmd.extend(rel_files)
+        logger.debug(f"[EslintTool] Running: {' '.join(cmd)} (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]
+        issues: list = parse_eslint_output(output=output)
+        issues_count: int = len(issues)
+        success: bool = issues_count == 0
+
+        # Standardize: suppress ESLint's informational output when no issues
+        # so the unified logger prints a single, consistent success line.
+        if success:
+            output = None
+
+        return ToolResult(
+            name=self.name,
+            success=success,
+            output=output,
+            issues_count=issues_count,
+            issues=issues,
+        )
+
+    def fix(
+        self,
+        paths: list[str],
+    ) -> ToolResult:
+        """Fix auto-fixable issues in files with ESLint.
+
+        Args:
+            paths: List of file or directory paths to fix
+
+        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)
+        eslint_files: list[str] = walk_files_with_excludes(
+            paths=paths,
+            file_patterns=self.config.file_patterns,
+            exclude_patterns=self.exclude_patterns,
+            include_venv=self.include_venv,
+        )
+        if not eslint_files:
+            return Tool.to_result(
+                name=self.name,
+                success=True,
+                output="No files to fix.",
+                issues_count=0,
+            )
+
+        # First, check for issues before fixing
+        cwd: str = self.get_cwd(paths=eslint_files)
+        rel_files: list[str] = [
+            os.path.relpath(f, cwd) if cwd else f for f in eslint_files
+        ]
+
+        # Get Lintro config injection args if available
+        config_args = self._build_config_args()
+
+        # Check for issues first
+        check_cmd: list[str] = self._get_executable_command(tool_name="eslint") + [
+            "--format",
+            "json",
+        ]
+        if config_args:
+            check_cmd.extend(config_args)
+        check_cmd.extend(rel_files)
+        logger.debug(f"[EslintTool] Checking: {' '.join(check_cmd)} (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
+        initial_issues: list = parse_eslint_output(output=check_output)
+        initial_count: int = len(initial_issues)
+
+        # Now fix the issues
+        fix_cmd: list[str] = self._get_executable_command(tool_name="eslint") + [
+            "--fix",
+        ]
+        if config_args:
+            fix_cmd.extend(config_args)
+        fix_cmd.extend(rel_files)
+        logger.debug(f"[EslintTool] Fixing: {' '.join(fix_cmd)} (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
+        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_eslint_output(output=final_check_output)
+        remaining_count: int = len(remaining_issues)
+
+        # Calculate fixed issues
+        fixed_count: int = max(0, initial_count - remaining_count)
+
+        # Build output message
+        output_lines: list[str] = []
+        if fixed_count > 0:
+            output_lines.append(f"Fixed {fixed_count} issue(s)")
+
+        if remaining_count > 0:
+            output_lines.append(
+                f"Found {remaining_count} issue(s) that cannot be auto-fixed",
+            )
+            for issue in remaining_issues[:5]:
+                output_lines.append(f"  {issue.file} - {issue.message}")
+            if len(remaining_issues) > 5:
+                output_lines.append(f"  ... and {len(remaining_issues) - 5} more")
+
+        # If there were no initial issues, rely on the logger's unified
+        # success line (avoid duplicate "No issues found" lines here)
+        elif remaining_count == 0 and fixed_count > 0:
+            output_lines.append("All issues were successfully auto-fixed")
+
+        # Add verbose raw fix output only when explicitly requested
+        if (
+            self.options.get("verbose_fix_output", False)
+            and fix_output
+            and fix_output.strip()
+        ):
+            output_lines.append(f"Fix output:\n{fix_output}")
+
+        final_output: str | None = "\n".join(output_lines) if output_lines else None
+
+        # Success means no remaining issues
+        success: bool = remaining_count == 0
+
+        # Use only remaining issues (post-fix list) to avoid duplicates
+        # The formatter relies on metadata counters (initial_issues_count,
+        # fixed_issues_count, remaining_issues_count) for summaries
+        all_issues = 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 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,
+        )