lintro 0.5.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

lintro/tools/implementations/tool_black.py

@@ -0,0 +1,261 @@
+"""Black Python formatter integration.
+
+Black is an opinionated Python formatter. We wire it as a formatter-only tool
+that cooperates with Ruff by default: when both are run, Ruff keeps linting and
+Black handles formatting. Users can override via --tool-options.
+
+Project: https://github.com/psf/black
+"""
+
+from __future__ import annotations
+
+import os
+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_parser import parse_black_output
+from lintro.tools.core.tool_base import BaseTool
+from lintro.utils.tool_utils import walk_files_with_excludes
+
+BLACK_DEFAULT_TIMEOUT: int = 30
+BLACK_DEFAULT_PRIORITY: int = 90  # Prefer Black ahead of Ruff formatting
+BLACK_FILE_PATTERNS: list[str] = ["*.py", "*.pyi"]
+
+
+@dataclass
+class BlackTool(BaseTool):
+    """Black Python formatter integration."""
+
+    name: str = "black"
+    description: str = "Opinionated Python code formatter"
+    can_fix: bool = True
+    config: ToolConfig = field(
+        default_factory=lambda: ToolConfig(
+            priority=BLACK_DEFAULT_PRIORITY,
+            conflicts_with=[],  # Compatible with Ruff (lint); no direct conflicts
+            file_patterns=BLACK_FILE_PATTERNS,
+            tool_type=ToolType.FORMATTER,
+            options={
+                "line_length": None,
+                "target_version": None,
+                "fast": False,  # Do not use --fast by default
+                "preview": False,  # Do not enable preview by default
+                "diff": False,  # Default to standard output messages
+            },
+        ),
+    )
+
+    def set_options(
+        self,
+        line_length: int | None = None,
+        target_version: str | None = None,
+        fast: bool | None = None,
+        preview: bool | None = None,
+        diff: bool | None = None,
+        **kwargs,
+    ) -> None:
+        """Set Black-specific options with validation.
+
+        Args:
+            line_length: Optional line length override.
+            target_version: String per Black CLI (e.g., "py313").
+            fast: Use --fast mode (skip safety checks).
+            preview: Enable preview style.
+            diff: Show diffs in output when formatting.
+            **kwargs: Additional base options like ``timeout``, ``exclude_patterns``,
+                and ``include_venv`` that are handled by ``BaseTool``.
+
+        Raises:
+            ValueError: If any provided option has an invalid type.
+        """
+        if line_length is not None and not isinstance(line_length, int):
+            raise ValueError("line_length must be an integer")
+        if target_version is not None and not isinstance(target_version, str):
+            raise ValueError("target_version must be a string")
+        if fast is not None and not isinstance(fast, bool):
+            raise ValueError("fast must be a boolean")
+        if preview is not None and not isinstance(preview, bool):
+            raise ValueError("preview must be a boolean")
+        if diff is not None and not isinstance(diff, bool):
+            raise ValueError("diff must be a boolean")
+
+        options = {
+            "line_length": line_length,
+            "target_version": target_version,
+            "fast": fast,
+            "preview": preview,
+            "diff": diff,
+        }
+        # Remove None values
+        options = {k: v for k, v in options.items() if v is not None}
+        super().set_options(**options, **kwargs)
+
+    def _build_common_args(self) -> list[str]:
+        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"])])
+        if self.options.get("fast"):
+            args.append("--fast")
+        if self.options.get("preview"):
+            args.append("--preview")
+        return args
+
+    def check(self, paths: list[str]) -> ToolResult:
+        """Check files using Black without applying changes.
+
+        Args:
+            paths: List of file or directory paths to check.
+
+        Returns:
+            ToolResult: Result containing success flag, issue count, and issues.
+        """
+        self._validate_paths(paths=paths)
+
+        py_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 py_files:
+            return ToolResult(
+                name=self.name,
+                success=True,
+                output="No files to check.",
+                issues_count=0,
+            )
+
+        cwd: str | None = self.get_cwd(paths=py_files)
+        rel_files: list[str] = [os.path.relpath(f, cwd) if cwd else f for f in py_files]
+
+        cmd: list[str] = self._get_executable_command(tool_name="black") + [
+            "--check",
+        ]
+        cmd.extend(self._build_common_args())
+        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),
+            cwd=cwd,
+        )
+
+        issues = parse_black_output(output=output)
+        count = len(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,
+        )
+
+    def fix(self, paths: list[str]) -> ToolResult:
+        """Format files using Black, returning standardized counts.
+
+        Args:
+            paths: List of file or directory paths to format.
+
+        Returns:
+            ToolResult: Result containing counts and any remaining issues.
+        """
+        self._validate_paths(paths=paths)
+
+        py_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 py_files:
+            return ToolResult(
+                name=self.name,
+                success=True,
+                output="No files to format.",
+                issues_count=0,
+            )
+
+        cwd: str | None = self.get_cwd(paths=py_files)
+        rel_files: list[str] = [os.path.relpath(f, cwd) if cwd else f for f in py_files]
+
+        # Build reusable check command (used for final verification)
+        check_cmd: list[str] = self._get_executable_command(tool_name="black") + [
+            "--check",
+        ]
+        check_cmd.extend(self._build_common_args())
+        check_cmd.extend(rel_files)
+
+        # 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.
+        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,
+            )
+            initial_issues = parse_black_output(output=check_output)
+            initial_count = len(initial_issues)
+
+        # Apply formatting
+        fix_cmd_base: list[str] = self._get_executable_command(tool_name="black")
+        fix_cmd: list[str] = list(fix_cmd_base)
+        if self.options.get("diff"):
+            # When diff is requested, ensure the flag is present on the format run
+            # so tests can assert its presence on the middle invocation.
+            fix_cmd.append("--diff")
+        fix_cmd.extend(self._build_common_args())
+        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,
+        )
+
+        # Final check for remaining differences
+        final_success, final_output = self._run_subprocess(
+            cmd=check_cmd,
+            timeout=self.options.get("timeout", BLACK_DEFAULT_TIMEOUT),
+            cwd=cwd,
+        )
+        remaining_issues = parse_black_output(output=final_output)
+        remaining_count = len(remaining_issues)
+
+        fixed_count = max(0, initial_count - remaining_count)
+
+        # Build concise summary
+        summary: list[str] = []
+        if fixed_count > 0:
+            summary.append(f"Fixed {fixed_count} issue(s)")
+        if remaining_count > 0:
+            summary.append(
+                f"Found {remaining_count} issue(s) that cannot be auto-fixed",
+            )
+        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)
+
+        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,
+            initial_issues_count=initial_count,
+            fixed_issues_count=fixed_count,
+            remaining_issues_count=remaining_count,
+        )

lintro/tools/implementations/tool_prettier.py

@@ -233,7 +233,7 @@ class PrettierTool(BaseTool):
 
         if remaining_count > 0:
             output_lines.append(
-                f"Found {remaining_count} issue(s) that cannot be auto-fixed"
+                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}")

lintro/tools/implementations/tool_ruff.py

@@ -252,12 +252,25 @@ class RuffTool(BaseTool):
             cmd.append("--isolated")
 
         # Add configuration options
-        if self.options.get("select"):
-            cmd.extend(["--select", ",".join(self.options["select"])])
-        if self.options.get("ignore"):
-            cmd.extend(["--ignore", ",".join(self.options["ignore"])])
-        if self.options.get("extend_select"):
-            cmd.extend(["--extend-select", ",".join(self.options["extend_select"])])
+        selected_rules = list(self.options.get("select") or [])
+        ignored_rules = set(self.options.get("ignore") or [])
+        extend_selected_rules = list(self.options.get("extend_select") or [])
+
+        # Ensure E501 is included when selecting E-family unless explicitly ignored
+        if (
+            "E" in selected_rules
+            and "E501" not in ignored_rules
+            and "E501" not in selected_rules
+            and "E501" not in extend_selected_rules
+        ):
+            extend_selected_rules.append("E501")
+
+        if selected_rules:
+            cmd.extend(["--select", ",".join(selected_rules)])
+        if ignored_rules:
+            cmd.extend(["--ignore", ",".join(sorted(ignored_rules))])
+        if extend_selected_rules:
+            cmd.extend(["--extend-select", ",".join(extend_selected_rules)])
         if self.options.get("extend_ignore"):
             cmd.extend(["--extend-ignore", ",".join(self.options["extend_ignore"])])
         if self.options.get("line_length"):
@@ -366,7 +379,9 @@ class RuffTool(BaseTool):
         success_lint: bool
         output_lint: str
         success_lint, output_lint = self._run_subprocess(
-            cmd=cmd, timeout=timeout, cwd=cwd
+            cmd=cmd,
+            timeout=timeout,
+            cwd=cwd,
         )
         lint_issues = parse_ruff_output(output=output_lint)
         lint_issues_count: int = len(lint_issues)
@@ -475,20 +490,23 @@ class RuffTool(BaseTool):
         initial_count: int = len(initial_issues)
 
         # Also check formatting issues before fixing
-        format_cmd_check: list[str] = self._build_format_command(
-            files=python_files,
-            check_only=True,
-        )
-        success_format_check: bool
-        output_format_check: str
-        success_format_check, output_format_check = self._run_subprocess(
-            cmd=format_cmd_check,
-            timeout=timeout,
-        )
-        format_files = parse_ruff_format_check_output(output=output_format_check)
-        initial_format_count: int = len(format_files)
+        initial_format_count: int = 0
+        format_files: list[str] = []
+        if self.options.get("format", False):
+            format_cmd_check: list[str] = self._build_format_command(
+                files=python_files,
+                check_only=True,
+            )
+            success_format_check: bool
+            output_format_check: str
+            success_format_check, output_format_check = self._run_subprocess(
+                cmd=format_cmd_check,
+                timeout=timeout,
+            )
+            format_files = parse_ruff_format_check_output(output=output_format_check)
+            initial_format_count = len(format_files)
 
-        # Total initial issues (linting + formatting)
+        # Track initial totals separately for accurate fixed/remaining math
         total_initial_count: int = initial_count + initial_format_count
 
         # Optionally run ruff check --fix (lint fixes)
@@ -502,9 +520,12 @@ class RuffTool(BaseTool):
             remaining_issues = parse_ruff_output(output=output)
             remaining_count = len(remaining_issues)
 
-        # Calculate how many issues were actually fixed
-        # Add formatting fixes if formatter ran
-        fixed_count: int = total_initial_count - remaining_count
+        # Compute fixed lint issues by diffing initial vs remaining (internal only)
+        # Not used for display; summary counts reflect totals.
+
+        # Calculate how many lint issues were actually fixed
+        fixed_lint_count: int = max(0, initial_count - remaining_count)
+        fixed_count: int = fixed_lint_count
 
         # Do not print raw initial counts; keep output concise and unified
 
@@ -576,9 +597,9 @@ class RuffTool(BaseTool):
                 cmd=format_cmd,
                 timeout=timeout,
             )
-            # If we detected formatting issues initially, consider them fixed now
+            # Formatting fixes are counted separately from lint fixes
             if initial_format_count > 0:
-                fixed_count += initial_format_count
+                fixed_count = fixed_lint_count + initial_format_count
             # Suppress raw formatter output for consistency; rely on unified summary
             # Only consider formatting failure if there are actual formatting
             # issues. Don't fail the overall operation just because formatting
@@ -611,6 +632,7 @@ class RuffTool(BaseTool):
             output=final_output,
             # For fix operations, issues_count represents remaining for summaries
             issues_count=remaining_count,
+            # Display remaining issues only to align tables with summary counts
             issues=remaining_issues,
             initial_issues_count=total_initial_count,
             fixed_issues_count=fixed_count,

lintro/tools/tool_enum.py

@@ -4,6 +4,7 @@ from enum import Enum
 
 from lintro.tools.implementations.tool_actionlint import ActionlintTool
 from lintro.tools.implementations.tool_bandit import BanditTool
+from lintro.tools.implementations.tool_black import BlackTool
 from lintro.tools.implementations.tool_darglint import DarglintTool
 from lintro.tools.implementations.tool_hadolint import HadolintTool
 from lintro.tools.implementations.tool_prettier import PrettierTool
@@ -12,6 +13,7 @@ from lintro.tools.implementations.tool_yamllint import YamllintTool
 
 
 class ToolEnum(Enum):
+    BLACK = BlackTool
     DARGLINT = DarglintTool
     HADOLINT = HadolintTool
     PRETTIER = PrettierTool

lintro/utils/ascii_normalize_cli.py

@@ -37,7 +37,9 @@ def main() -> int:
     parser.add_argument("--width", type=int, default=80)
     parser.add_argument("--height", type=int, default=20)
     parser.add_argument(
-        "--align", choices=["left", "center", "right"], default="center"
+        "--align",
+        choices=["left", "center", "right"],
+        default="center",
     )
     parser.add_argument(
         "--valign",

lintro/utils/config.py

@@ -37,3 +37,19 @@ def load_lintro_tool_config(tool_name: str) -> dict[str, Any]:
     if isinstance(section, dict):
         return section
     return {}
+
+
+def load_post_checks_config() -> dict[str, Any]:
+    """Load post-checks configuration from pyproject.
+
+    Returns:
+        Dict with keys like:
+            - enabled: bool
+            - tools: list[str]
+            - enforce_failure: bool
+    """
+    cfg = _load_pyproject()
+    section = cfg.get("post_checks", {})
+    if isinstance(section, dict):
+        return section
+    return {}

lintro/utils/console_logger.py

@@ -20,6 +20,7 @@ TOOL_EMOJIS: dict[str, str] = {
     "darglint": "📝",
     "hadolint": "🐳",
     "yamllint": "📄",
+    "black": "🖤",
 }
 DEFAULT_EMOJI: str = "🔧"
 BORDER_LENGTH: int = 70
@@ -218,6 +219,35 @@ class SimpleLintroLogger:
 
         logger.debug(f"Starting tool: {tool_name}")
 
+    def print_post_checks_header(
+        self,
+        action: str,
+    ) -> None:
+        """Print a distinct header separating the post-checks phase.
+
+        Args:
+            action: str: The action being performed (e.g., 'check', 'fmt').
+        """
+        # Use a heavy unicode border and magenta coloring to stand out
+        border_char: str = "━"
+        border: str = border_char * BORDER_LENGTH
+        title_styled: str = click.style(
+            text="🚦  POST-CHECKS",
+            fg="magenta",
+            bold=True,
+        )
+        subtitle_styled: str = click.style(
+            text=("Running optional follow-up checks after primary tools"),
+            fg="magenta",
+        )
+
+        self.console_output(text="")
+        self.console_output(text=border, color="magenta")
+        self.console_output(text=title_styled)
+        self.console_output(text=subtitle_styled)
+        self.console_output(text=border, color="magenta")
+        self.console_output(text="")
+
     def print_tool_result(
         self,
         tool_name: str,
@@ -327,19 +357,25 @@ class SimpleLintroLogger:
                 if fixed_count > 0 and remaining_count == 0:
                     self.success(message=f"✓ {fixed_count} fixed")
                 elif fixed_count > 0 and remaining_count > 0:
-                    self.console_output(text=f"✓ {fixed_count} fixed", color="green")
                     self.console_output(
-                        text=f"✗ {remaining_count} remaining", color="red"
+                        text=f"✓ {fixed_count} fixed",
+                        color="green",
+                    )
+                    self.console_output(
+                        text=f"✗ {remaining_count} remaining",
+                        color="red",
                     )
                 elif remaining_count > 0:
                     self.console_output(
-                        text=f"✗ {remaining_count} remaining", color="red"
+                        text=f"✗ {remaining_count} remaining",
+                        color="red",
                     )
                 elif initial_count > 0:
                     # If we found initial issues but no specific fixed/remaining counts,
                     # show the initial count as found
                     self.console_output(
-                        text=f"✗ Found {initial_count} issues", color="red"
+                        text=f"✗ Found {initial_count} issues",
+                        color="red",
                     )
                 else:
                     # Fallback to original behavior
@@ -415,7 +451,7 @@ class SimpleLintroLogger:
         # Build summary table
         self._print_summary_table(action=action, tool_results=tool_results)
 
-        # Final status and ASCII art
+        # Totals line and ASCII art
         if action == "fmt":
             # For format commands, track both fixed and remaining issues
             # Use standardized counts when provided by tools
@@ -448,7 +484,11 @@ class SimpleLintroLogger:
                         elif not getattr(result, "success", True):
                             total_remaining += DEFAULT_REMAINING_COUNT
 
-            # Show ASCII art as the last item; no status text after art
+            # Show totals line then ASCII art
+            totals_line: str = (
+                f"Totals: fixed={total_fixed}, remaining={total_remaining}"
+            )
+            self.console_output(text=click.style(totals_line, fg="cyan"))
             self._print_ascii_art_format(total_remaining=total_remaining)
             logger.debug(
                 f"{action} completed with {total_fixed} fixed, "
@@ -465,11 +505,13 @@ class SimpleLintroLogger:
             total_for_art: int = (
                 total_issues if not any_failed else max(1, total_issues)
             )
-            # Show ASCII art as the last item; no status text after art
+            # Show totals line then ASCII art
+            totals_line_chk: str = f"Total issues: {total_issues}"
+            self.console_output(text=click.style(totals_line_chk, fg="cyan"))
             self._print_ascii_art(total_issues=total_for_art)
             logger.debug(
                 f"{action} completed with {total_issues} total issues"
-                + (" and failures" if any_failed else "")
+                + (" and failures" if any_failed else ""),
             )
 
     def _print_summary_table(
@@ -502,7 +544,9 @@ class SimpleLintroLogger:
                     # Format operations: show fixed count and remaining status
                     if success:
                         status_display: str = click.style(
-                            "✅ PASS", fg="green", bold=True
+                            "✅ PASS",
+                            fg="green",
+                            bold=True,
                         )
                     else:
                         status_display = click.style("❌ FAIL", fg="red", bold=True)
@@ -516,7 +560,9 @@ class SimpleLintroLogger:
                         ),
                     ):
                         fixed_display: str = click.style(
-                            "SKIPPED", fg="yellow", bold=True
+                            "SKIPPED",
+                            fg="yellow",
+                            bold=True,
                         )
                         remaining_display: str = click.style(
                             "SKIPPED",
@@ -585,7 +631,9 @@ class SimpleLintroLogger:
                         ),
                     ):
                         issues_display: str = click.style(
-                            "SKIPPED", fg="yellow", bold=True
+                            "SKIPPED",
+                            fg="yellow",
+                            bold=True,
                         )
                     else:
                         issues_display = click.style(

lintro/utils/output_manager.py

@@ -230,7 +230,7 @@ class OutputManager:
             if hasattr(r, "issues") and r.issues:
                 html.append(
                     "<table border='1'><tr><th>File</th><th>Line</th><th>Code</th>"
-                    "<th>Message</th></tr>"
+                    "<th>Message</th></tr>",
                 )
                 for issue in r.issues:
                     file: str = _html_escape(getattr(issue, "file", ""))
@@ -239,7 +239,7 @@ class OutputManager:
                     msg: str = _html_escape(getattr(issue, "message", ""))
                     html.append(
                         f"<tr><td>{file}</td><td>{line}</td><td>{code}</td>"
-                        f"<td>{msg}</td></tr>"
+                        f"<td>{msg}</td></tr>",
                     )
                 html.append("</table>")
             else: