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

lintro/tools/implementations/tool_actionlint.py

@@ -7,9 +7,11 @@ structured issues, and returns a normalized `ToolResult`.
 
 from __future__ import annotations
 
+import contextlib
 import subprocess  # nosec B404 - used safely with shell disabled
 from dataclasses import dataclass, field
 
+import click
 from loguru import logger
 
 from lintro.enums.tool_type import ToolType
@@ -66,6 +68,55 @@ class ActionlintTool(BaseTool):
         """
         return ["actionlint"]
 
+    def _process_file(
+        self,
+        file_path: str,
+        base_cmd: list[str],
+        timeout: int,
+        all_outputs: list[str],
+        all_issues: list,
+        skipped_files: list[str],
+        all_success: bool,
+        execution_failures: int,
+    ) -> tuple[bool, int]:
+        """Process a single file with actionlint.
+
+        Args:
+            file_path: Path to the file to process.
+            base_cmd: Base command list for actionlint.
+            timeout: Timeout in seconds.
+            all_outputs: List to append raw output to.
+            all_issues: List to extend with parsed issues.
+            skipped_files: List to append skipped file paths to.
+            all_success: Current success flag.
+            execution_failures: Current execution failures count.
+
+        Returns:
+            Tuple of (updated_all_success, updated_execution_failures).
+        """
+        cmd = base_cmd + [file_path]
+        try:
+            success, output = self._run_subprocess(cmd=cmd, timeout=timeout)
+            issues = parse_actionlint_output(output)
+            if not success:
+                all_success = False
+            # Preserve output when subprocess fails even if parsing yields no issues
+            if output and (issues or not success):
+                all_outputs.append(output)
+            if issues:
+                all_issues.extend(issues)
+        except subprocess.TimeoutExpired:
+            skipped_files.append(file_path)
+            all_success = False
+            # Count timeout as an execution failure
+            execution_failures += 1
+        except Exception as e:  # pragma: no cover
+            all_success = False
+            all_outputs.append(f"Error checking {file_path}: {e}")
+            # Count execution errors as failures
+            execution_failures += 1
+        return all_success, execution_failures
+
     def check(self, paths: list[str]) -> ToolResult:
         """Check GitHub Actions workflow files with actionlint.
 
@@ -76,6 +127,11 @@ class ActionlintTool(BaseTool):
             A `ToolResult` containing success status, aggregated output (if any),
             issue count, and parsed issues.
         """
+        # 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(
@@ -111,26 +167,60 @@ class ActionlintTool(BaseTool):
         all_outputs: list[str] = []
         all_issues = []
         all_success = True
+        execution_failures: int = 0
 
+        skipped_files: list[str] = []
         base_cmd = self._build_command()
-        for file_path in workflow_files:
-            cmd = base_cmd + [file_path]
-            try:
-                success, output = self._run_subprocess(cmd=cmd, timeout=timeout)
-                issues = parse_actionlint_output(output)
-                if not success:
-                    all_success = False
-                if issues:
-                    all_outputs.append(output)
-                    all_issues.extend(issues)
-            except subprocess.TimeoutExpired:
-                all_success = False
-                all_outputs.append(f"Timeout while checking {file_path}")
-            except Exception as e:  # pragma: no cover
-                all_success = False
-                all_outputs.append(f"Error checking {file_path}: {e}")
+
+        # Show progress bar only when processing multiple files
+        if len(workflow_files) >= 2:
+            files_to_iterate = click.progressbar(
+                workflow_files,
+                label="Processing files",
+                bar_template="%(label)s  %(info)s",
+            )
+            context_mgr = files_to_iterate
+        else:
+            files_to_iterate = workflow_files
+            context_mgr = contextlib.nullcontext()
+
+        with context_mgr:
+            for file_path in files_to_iterate:
+                all_success, execution_failures = self._process_file(
+                    file_path=file_path,
+                    base_cmd=base_cmd,
+                    timeout=timeout,
+                    all_outputs=all_outputs,
+                    all_issues=all_issues,
+                    skipped_files=skipped_files,
+                    all_success=all_success,
+                    execution_failures=execution_failures,
+                )
 
         combined_output = "\n".join(all_outputs) if all_outputs else None
+        if skipped_files:
+            timeout_msg = (
+                f"Skipped {len(skipped_files)} file(s) due to timeout "
+                f"({timeout}s limit exceeded):"
+            )
+            for file in skipped_files:
+                timeout_msg += f"\n  - {file}"
+            if combined_output:
+                combined_output = f"{combined_output}\n\n{timeout_msg}"
+            else:
+                combined_output = timeout_msg
+        # Add summary of execution failures (non-timeout errors) if any
+        non_timeout_failures = execution_failures - len(skipped_files)
+        if non_timeout_failures > 0:
+            failure_msg = (
+                f"Failed to process {non_timeout_failures} file(s) "
+                "due to execution errors"
+            )
+            if combined_output:
+                combined_output = f"{combined_output}\n\n{failure_msg}"
+            else:
+                combined_output = failure_msg
+        # issues_count reflects only linting issues, not execution failures
         return ToolResult(
             name=self.name,
             success=all_success,

lintro/tools/implementations/tool_bandit.py

@@ -2,7 +2,6 @@
 
 import json
 import os
-import shutil
 import subprocess  # nosec B404 - deliberate, shell disabled
 import tomllib
 from dataclasses import dataclass, field
@@ -243,15 +242,10 @@ class BanditTool(BaseTool):
         Returns:
             list[str]: List of command arguments.
         """
-        # Prefer the Bandit CLI directly; avoid module execution which can fail
-        # when Bandit isn't installed in the current venv. Fall back to uvx
-        # (which can run ephemeral tools), then finally to plain name.
-        if shutil.which("bandit"):
-            exec_cmd: list[str] = ["bandit"]
-        elif shutil.which("uvx"):
-            exec_cmd = ["uvx", "bandit"]
-        else:
-            exec_cmd = ["bandit"]
+        # Resolve executable via BaseTool preferences to ensure reliable
+        # execution inside the active environment (prefers 'uv run bandit' when
+        # available), falling back to a direct executable.
+        exec_cmd: list[str] = self._get_executable_command("bandit")
 
         cmd: list[str] = exec_cmd + ["-r"]
 
@@ -325,10 +319,12 @@ class BanditTool(BaseTool):
 
         Returns:
             ToolResult: ToolResult instance.
-
-        Raises:
-            subprocess.TimeoutExpired: If the subprocess exceeds the timeout.
         """
+        # 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(
@@ -367,26 +363,33 @@ class BanditTool(BaseTool):
         cmd: list[str] = self._build_check_command(files=rel_files)
 
         output: str
-        # Run Bandit and capture both stdout and stderr; Bandit may emit logs
-        # and JSON to different streams depending on version/settings.
+        execution_failure: bool = False
+        # Run Bandit via the shared safe runner in BaseTool. This enforces
+        # argument validation and consistent subprocess handling across tools.
         try:
-            result = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
+            success, combined = self._run_subprocess(
+                cmd=cmd,
                 timeout=timeout,
                 cwd=cwd,
-            )  # nosec B603 - cmd args list; no shell
-            # Combine streams for robust JSON extraction
-            stdout_text: str = result.stdout or ""
-            stderr_text: str = result.stderr or ""
-            output = (stdout_text + "\n" + stderr_text).strip()
-            rc: int = result.returncode
+            )
+            output = (combined or "").strip()
+            rc: int = 0 if success else 1
         except subprocess.TimeoutExpired:
-            raise
+            # Handle timeout gracefully
+            execution_failure = True
+            timeout_msg = (
+                f"Bandit execution timed out ({timeout}s limit exceeded).\n\n"
+                "This may indicate:\n"
+                "  - Large codebase taking too long to process\n"
+                "  - Need to increase timeout via --tool-options bandit:timeout=N"
+            )
+            output = timeout_msg
+            rc = 1
         except Exception as e:
             logger.error(f"Failed to run Bandit: {e}")
-            output = ""
+            output = f"Bandit failed: {e}"
+            execution_failure = True
+            rc = 1
 
         # Parse the JSON output
         try:
@@ -409,12 +412,14 @@ class BanditTool(BaseTool):
             issues_count = len(issues)
 
             # Bandit returns 0 if no issues; 1 if issues found (still successful run)
-            execution_success = len(bandit_data.get("errors", [])) == 0
+            execution_success = (
+                len(bandit_data.get("errors", [])) == 0 and not execution_failure
+            )
 
             return ToolResult(
                 name=self.name,
                 success=execution_success,
-                output=None,
+                output=output if execution_failure else None,
                 issues_count=issues_count,
                 issues=issues,
             )

lintro/tools/implementations/tool_black.py

@@ -10,12 +10,14 @@ Project: https://github.com/psf/black
 from __future__ import annotations
 
 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 ToolConfig, ToolResult
+from lintro.parsers.black.black_issue import BlackIssue
 from lintro.parsers.black.black_parser import parse_black_output
 from lintro.tools.core.tool_base import BaseTool
 from lintro.utils.tool_utils import walk_files_with_excludes
@@ -94,17 +96,165 @@ class BlackTool(BaseTool):
         super().set_options(**options, **kwargs)
 
     def _build_common_args(self) -> list[str]:
+        """Build common CLI arguments for Black.
+
+        Uses Lintro config injection when available, otherwise falls back
+        to options-based configuration.
+
+        Returns:
+            list[str]: CLI arguments for Black.
+        """
         args: list[str] = []
-        if self.options.get("line_length"):
-            args.extend(["--line-length", str(self.options["line_length"])])
-        if self.options.get("target_version"):
-            args.extend(["--target-version", str(self.options["target_version"])])
+
+        # Try Lintro config injection first (--config flag)
+        config_args = self._build_config_args()
+        if config_args:
+            args.extend(config_args)
+        else:
+            # Fallback to options-based configuration
+            if self.options.get("line_length"):
+                args.extend(["--line-length", str(self.options["line_length"])])
+            if self.options.get("target_version"):
+                args.extend(["--target-version", str(self.options["target_version"])])
+
+        # These flags are always passed via CLI (not in config file)
         if self.options.get("fast"):
             args.append("--fast")
         if self.options.get("preview"):
             args.append("--preview")
         return args
 
+    def _check_line_length_violations(
+        self,
+        files: list[str],
+        cwd: str | None,
+    ) -> list[BlackIssue]:
+        """Check for line length violations using Ruff's E501 rule.
+
+        This catches lines that exceed the line length limit but cannot be
+        safely wrapped by Black. Black's --check mode only reports files that
+        would be reformatted, so it misses unwrappable long lines.
+
+        Args:
+            files: List of file paths (relative to cwd) to check.
+            cwd: Working directory for the check.
+
+        Returns:
+            list[BlackIssue]: List of line length violations converted to
+                BlackIssue objects.
+        """
+        if not files:
+            return []
+
+        # Import here to avoid circular dependency
+        from lintro.tools.implementations.tool_ruff import RuffTool
+
+        try:
+            ruff_tool = RuffTool()
+            # Use the same line_length as Black is configured with
+            line_length = self.options.get("line_length")
+            if line_length:
+                ruff_tool.set_options(
+                    select=["E501"],
+                    line_length=line_length,
+                    timeout=self.options.get("timeout", BLACK_DEFAULT_TIMEOUT),
+                )
+            else:
+                # If no line_length configured, use Ruff's default (88)
+                ruff_tool.set_options(
+                    select=["E501"],
+                    timeout=self.options.get("timeout", BLACK_DEFAULT_TIMEOUT),
+                )
+
+            # Convert relative paths to absolute paths for RuffTool
+            abs_files: list[str] = []
+            for file_path in files:
+                if cwd and not os.path.isabs(file_path):
+                    abs_files.append(os.path.abspath(os.path.join(cwd, file_path)))
+                else:
+                    abs_files.append(file_path)
+
+            # Run Ruff E501 check on the absolute file paths
+            ruff_result = ruff_tool.check(paths=abs_files)
+
+            # Convert Ruff E501 violations to BlackIssue objects
+            black_issues: list[BlackIssue] = []
+            if ruff_result.issues:
+                for ruff_issue in ruff_result.issues:
+                    # Only process E501 violations
+                    if hasattr(ruff_issue, "code") and ruff_issue.code == "E501":
+                        file_path = ruff_issue.file
+                        # Ensure absolute path
+                        if not os.path.isabs(file_path):
+                            if cwd:
+                                file_path = os.path.abspath(
+                                    os.path.join(cwd, file_path),
+                                )
+                            else:
+                                file_path = os.path.abspath(file_path)
+                        message = (
+                            f"Line {ruff_issue.line} exceeds line length limit "
+                            f"({ruff_issue.message})"
+                        )
+                        # Line length violations cannot be fixed by Black
+                        black_issues.append(
+                            BlackIssue(
+                                file=file_path,
+                                message=message,
+                                fixable=False,
+                            ),
+                        )
+
+        except Exception as e:
+            # If Ruff check fails, log but don't fail the entire Black check
+            logger.debug(f"Failed to check line length violations with Ruff: {e}")
+            return []
+
+        return black_issues
+
+    def _handle_timeout_error(
+        self,
+        timeout_val: int,
+        initial_count: int | None = None,
+    ) -> ToolResult:
+        """Handle timeout errors consistently across all Black operations.
+
+        Args:
+            timeout_val: The timeout value that was exceeded.
+            initial_count: Optional initial issues count for fix operations.
+
+        Returns:
+            ToolResult: Standardized timeout error result.
+        """
+        timeout_msg = (
+            f"Black 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 black:timeout=N"
+        )
+        if initial_count is not None:
+            # Fix operation timeout - preserve known initial count
+            return ToolResult(
+                name=self.name,
+                success=False,
+                output=timeout_msg,
+                issues_count=max(initial_count, 1),
+                issues=[],
+                initial_issues_count=(
+                    initial_count if not self.options.get("diff") else 0
+                ),
+                fixed_issues_count=0,
+                remaining_issues_count=max(initial_count, 1),
+            )
+        # Check operation timeout
+        return ToolResult(
+            name=self.name,
+            success=False,
+            output=timeout_msg,
+            issues_count=1,  # Count timeout as execution failure
+            issues=[],
+        )
+
     def check(self, paths: list[str]) -> ToolResult:
         """Check files using Black without applying changes.
 
@@ -114,6 +264,11 @@ class BlackTool(BaseTool):
         Returns:
             ToolResult: Result containing success flag, issue count, and issues.
         """
+        # Check version requirements
+        version_result = self._verify_tool_version()
+        if version_result is not None:
+            return version_result
+
         self._validate_paths(paths=paths)
 
         py_files: list[str] = walk_files_with_excludes(
@@ -141,21 +296,36 @@ class BlackTool(BaseTool):
         cmd.extend(rel_files)
 
         logger.debug(f"[BlackTool] Running: {' '.join(cmd)} (cwd={cwd})")
-        success, output = self._run_subprocess(
-            cmd=cmd,
-            timeout=self.options.get("timeout", BLACK_DEFAULT_TIMEOUT),
+        timeout_val: int = self.options.get("timeout", BLACK_DEFAULT_TIMEOUT)
+        try:
+            success, output = self._run_subprocess(
+                cmd=cmd,
+                timeout=timeout_val,
+                cwd=cwd,
+            )
+        except subprocess.TimeoutExpired:
+            return self._handle_timeout_error(timeout_val)
+
+        black_issues = parse_black_output(output=output)
+
+        # Also check for line length violations that Black cannot wrap
+        # This catches E501 violations that Ruff finds but Black doesn't report
+        line_length_issues = self._check_line_length_violations(
+            files=rel_files,
             cwd=cwd,
         )
 
-        issues = parse_black_output(output=output)
-        count = len(issues)
+        # Combine Black formatting issues with line length violations
+        all_issues = black_issues + line_length_issues
+        count = len(all_issues)
+
         # In check mode, success means no differences
         return ToolResult(
             name=self.name,
             success=(success and count == 0),
             output=None if count == 0 else output,
             issues_count=count,
-            issues=issues,
+            issues=all_issues,
         )
 
     def fix(self, paths: list[str]) -> ToolResult:
@@ -167,6 +337,11 @@ class BlackTool(BaseTool):
         Returns:
             ToolResult: Result containing counts and any remaining issues.
         """
+        # Check version requirements
+        version_result = self._verify_tool_version()
+        if version_result is not None:
+            return version_result
+
         self._validate_paths(paths=paths)
 
         py_files: list[str] = walk_files_with_excludes(
@@ -196,15 +371,19 @@ class BlackTool(BaseTool):
         # When diff is requested, skip the initial check to ensure the middle
         # invocation is the formatting run (as exercised by unit tests) and to
         # avoid redundant subprocess calls.
+        timeout_val: int = self.options.get("timeout", BLACK_DEFAULT_TIMEOUT)
         if self.options.get("diff"):
             initial_issues = []
             initial_count = 0
         else:
-            _, check_output = self._run_subprocess(
-                cmd=check_cmd,
-                timeout=self.options.get("timeout", BLACK_DEFAULT_TIMEOUT),
-                cwd=cwd,
-            )
+            try:
+                _, check_output = self._run_subprocess(
+                    cmd=check_cmd,
+                    timeout=timeout_val,
+                    cwd=cwd,
+                )
+            except subprocess.TimeoutExpired:
+                return self._handle_timeout_error(timeout_val, initial_count=0)
             initial_issues = parse_black_output(output=check_output)
             initial_count = len(initial_issues)
 
@@ -219,22 +398,50 @@ class BlackTool(BaseTool):
         fix_cmd.extend(rel_files)
 
         logger.debug(f"[BlackTool] Fixing: {' '.join(fix_cmd)} (cwd={cwd})")
-        _, fix_output = self._run_subprocess(
-            cmd=fix_cmd,
-            timeout=self.options.get("timeout", BLACK_DEFAULT_TIMEOUT),
-            cwd=cwd,
-        )
+        try:
+            _, fix_output = self._run_subprocess(
+                cmd=fix_cmd,
+                timeout=timeout_val,
+                cwd=cwd,
+            )
+        except subprocess.TimeoutExpired:
+            return self._handle_timeout_error(timeout_val, initial_count=initial_count)
 
         # Final check for remaining differences
-        final_success, final_output = self._run_subprocess(
-            cmd=check_cmd,
-            timeout=self.options.get("timeout", BLACK_DEFAULT_TIMEOUT),
+        try:
+            final_success, final_output = self._run_subprocess(
+                cmd=check_cmd,
+                timeout=timeout_val,
+                cwd=cwd,
+            )
+        except subprocess.TimeoutExpired:
+            return self._handle_timeout_error(timeout_val, initial_count=initial_count)
+        remaining_issues = parse_black_output(output=final_output)
+
+        # Also check for line length violations that Black cannot wrap
+        # This catches E501 violations that Ruff finds but Black doesn't report
+        line_length_issues = self._check_line_length_violations(
+            files=rel_files,
             cwd=cwd,
         )
-        remaining_issues = parse_black_output(output=final_output)
-        remaining_count = len(remaining_issues)
 
-        fixed_count = max(0, initial_count - remaining_count)
+        # Combine Black formatting issues with line length violations
+        all_remaining_issues = remaining_issues + line_length_issues
+        remaining_count = len(all_remaining_issues)
+
+        # Parse per-file reformats from the formatting run to display in console
+        fixed_issues_parsed = parse_black_output(output=fix_output)
+        fixed_count_from_output = len(fixed_issues_parsed)
+
+        # Calculate fixed count: use reformatted files count if available,
+        # otherwise calculate from initial - remaining
+        if fixed_count_from_output > 0:
+            fixed_count = fixed_count_from_output
+        else:
+            # Subtract only Black-related remaining issues (exclude line-length)
+            line_length_issues_count = len(line_length_issues)
+            remaining_black_count = max(0, remaining_count - line_length_issues_count)
+            fixed_count = max(0, initial_count - remaining_black_count)
 
         # Build concise summary
         summary: list[str] = []
@@ -246,15 +453,15 @@ class BlackTool(BaseTool):
             )
         final_summary = "\n".join(summary) if summary else "No fixes applied."
 
-        # Parse per-file reformats from the formatting run to display in console
-        fixed_issues_parsed = parse_black_output(output=fix_output)
+        # Combine fixed and remaining issues so formatter can split them by fixability
+        all_issues = (fixed_issues_parsed or []) + all_remaining_issues
 
         return ToolResult(
             name=self.name,
             success=(remaining_count == 0),
             output=final_summary,
             issues_count=remaining_count,
-            issues=fixed_issues_parsed if fixed_issues_parsed else remaining_issues,
+            issues=all_issues,
             initial_issues_count=initial_count,
             fixed_issues_count=fixed_count,
             remaining_issues_count=remaining_count,