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

lintro/__init__.py

@@ -1,3 +1,3 @@
 """Lintro - A unified CLI core for code formatting, linting, and quality assurance."""
 
-__version__ = "0.5.3"
+__version__ = "0.6.0"

lintro/formatters/tools/actionlint_formatter.py

@@ -54,7 +54,7 @@ class ActionlintTableDescriptor(TableDescriptor):
                     issue.level,
                     issue.code or "",
                     issue.message,
-                ]
+                ],
             )
         return rows
 

lintro/formatters/tools/bandit_formatter.py

@@ -38,7 +38,7 @@ class BanditTableDescriptor(TableDescriptor):
                     f"{severity_icon} {issue.issue_severity}",
                     issue.issue_confidence,
                     issue.issue_text,
-                ]
+                ],
             )
         return rows
 

lintro/formatters/tools/black_formatter.py

@@ -0,0 +1,48 @@
+"""Formatter for Black issues."""
+
+from __future__ import annotations
+
+from lintro.formatters.core.table_descriptor import TableDescriptor
+from lintro.formatters.styles.csv import CsvStyle
+from lintro.formatters.styles.grid import GridStyle
+from lintro.formatters.styles.html import HtmlStyle
+from lintro.formatters.styles.json import JsonStyle
+from lintro.formatters.styles.markdown import MarkdownStyle
+from lintro.formatters.styles.plain import PlainStyle
+from lintro.parsers.black.black_issue import BlackIssue
+from lintro.utils.path_utils import normalize_file_path_for_display
+
+FORMAT_MAP = {
+    "plain": PlainStyle(),
+    "grid": GridStyle(),
+    "markdown": MarkdownStyle(),
+    "html": HtmlStyle(),
+    "json": JsonStyle(),
+    "csv": CsvStyle(),
+}
+
+
+class BlackTableDescriptor(TableDescriptor):
+    def get_columns(self) -> list[str]:
+        return ["File", "Message"]
+
+    def get_rows(self, issues: list[BlackIssue]) -> list[list[str]]:
+        rows: list[list[str]] = []
+        for issue in issues:
+            rows.append(
+                [
+                    normalize_file_path_for_display(issue.file),
+                    issue.message,
+                ],
+            )
+        return rows
+
+
+def format_black_issues(issues: list[BlackIssue], format: str = "grid") -> str:
+    descriptor = BlackTableDescriptor()
+    formatter = FORMAT_MAP.get(format, GridStyle())
+    columns = descriptor.get_columns()
+    rows = descriptor.get_rows(issues)
+    if format == "json":
+        return formatter.format(columns=columns, rows=rows, tool_name="black")
+    return formatter.format(columns=columns, rows=rows)

lintro/formatters/tools/darglint_formatter.py

@@ -63,7 +63,9 @@ def format_darglint_issues(
     # For JSON format, pass tool name
     if format == "json":
         formatted_table = formatter.format(
-            columns=columns, rows=rows, tool_name="darglint"
+            columns=columns,
+            rows=rows,
+            tool_name="darglint",
         )
     else:
         # For other formats, use standard formatting

lintro/parsers/black/black_issue.py

@@ -0,0 +1,22 @@
+"""Black issue models.
+
+This module defines lightweight dataclasses used to represent Black findings
+in a normalized form that Lintro formatters can consume.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class BlackIssue:
+    """Represents a Black formatting issue.
+
+    Attributes:
+        file: Path to the file with a formatting difference.
+        message: Short human-readable description (e.g., "Would reformat file").
+    """
+
+    file: str
+    message: str

lintro/parsers/black/black_parser.py

@@ -0,0 +1,90 @@
+"""Parser for Black output.
+
+Black commonly emits terse messages like:
+- "would reformat foo.py" (check mode with --check)
+- "reformatted foo.py" (fix mode)
+- a summary line like "1 file would be reformatted" or
+  "2 files reformatted" (with no per-file lines in some environments).
+
+We normalize items into ``BlackIssue`` objects so the table formatter can
+render consistent rows. When only a summary is present, we synthesize one
+``BlackIssue`` per counted file with ``file`` set to "<unknown>" so totals
+remain accurate across environments.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable
+
+from lintro.parsers.black.black_issue import BlackIssue
+
+_WOULD_REFORMAT = re.compile(r"^would reformat\s+(?P<file>.+)$", re.IGNORECASE)
+_REFORMATTED = re.compile(r"^reformatted\s+(?P<file>.+)$", re.IGNORECASE)
+_SUMMARY_WOULD = re.compile(
+    r"(?P<count>\d+)\s+file(?:s)?\s+would\s+be\s+reformatted\.?",
+    re.IGNORECASE,
+)
+_SUMMARY_REFORMATTED = re.compile(
+    r"(?P<count>\d+)\s+file(?:s)?\s+reformatted\.?",
+    re.IGNORECASE,
+)
+
+
+def _iter_issue_lines(lines: Iterable[str]) -> Iterable[str]:
+    for line in lines:
+        s = line.strip()
+        if not s:
+            continue
+        yield s
+
+
+def parse_black_output(output: str) -> list[BlackIssue]:
+    """Parse Black CLI output into a list of ``BlackIssue`` objects.
+
+    Args:
+        output: Raw stdout+stderr from a Black invocation.
+
+    Returns:
+        list[BlackIssue]: Per-file issues indicating formatting diffs. If only
+        a summary is present (no per-file lines), returns a synthesized list
+        sized to the summary count with ``file`` set to "<unknown>".
+    """
+    if not output:
+        return []
+
+    issues: list[BlackIssue] = []
+    for line in _iter_issue_lines(output.splitlines()):
+        m = _WOULD_REFORMAT.match(line)
+        if m:
+            issues.append(
+                BlackIssue(file=m.group("file"), message="Would reformat file"),
+            )
+            continue
+        m = _REFORMATTED.match(line)
+        if m:
+            issues.append(BlackIssue(file=m.group("file"), message="Reformatted file"))
+            continue
+
+    # Some environments (e.g., CI) may emit only a summary line without listing
+    # per-file entries. In that case, synthesize issues so counts remain
+    # consistent across environments.
+    if not issues:
+        m_sum = _SUMMARY_WOULD.search(output)
+        if not m_sum:
+            m_sum = _SUMMARY_REFORMATTED.search(output)
+        if m_sum:
+            try:
+                count = int(m_sum.group("count"))
+            except Exception:
+                count = 0
+            if count > 0:
+                for _ in range(count):
+                    issues.append(
+                        BlackIssue(
+                            file="<unknown>",
+                            message="Formatting change detected",
+                        ),
+                    )
+
+    return issues

lintro/parsers/darglint/darglint_parser.py

@@ -56,7 +56,7 @@ def parse_darglint_output(output: str) -> list[DarglintIssue]:
                 line=int(line_num),
                 code=code,
                 message=full_message,
-            )
+            ),
         )
         i = j
     return issues

lintro/parsers/hadolint/hadolint_parser.py

@@ -32,7 +32,7 @@ def parse_hadolint_output(output: str) -> list[HadolintIssue]:
 
     # Pattern for hadolint output: filename:line code level: message
     pattern: re.Pattern[str] = re.compile(
-        r"^(.+?):(\d+)\s+([A-Z]+\d+)\s+(error|warning|info|style):\s+(.+)$"
+        r"^(.+?):(\d+)\s+([A-Z]+\d+)\s+(error|warning|info|style):\s+(.+)$",
     )
 
     lines: list[str] = output.splitlines()
@@ -59,7 +59,7 @@ def parse_hadolint_output(output: str) -> list[HadolintIssue]:
                     level=level,
                     code=code,
                     message=message.strip(),
-                )
+                ),
             )
 
     return issues

lintro/parsers/ruff/ruff_parser.py

@@ -11,58 +11,109 @@ from lintro.parsers.ruff.ruff_issue import RuffIssue
 
 
 def parse_ruff_output(output: str) -> list[RuffIssue]:
-    """Parse ruff JSON output into a list of RuffIssue objects.
+    """Parse Ruff JSON or JSON Lines output into `RuffIssue` objects.
+
+    Supports multiple Ruff schema variants across versions by accepting:
+    - JSON array of issue objects
+    - JSON Lines (one object per line)
+
+    Field name variations handled:
+    - location: "location" or "start" with keys "row"|"line" and
+      "column"|"col"
+    - end location: "end_location" or "end" with keys "row"|"line" and
+      "column"|"col"
+    - filename: "filename" (preferred) or "file"
 
     Args:
-        output: The raw JSON output from ruff
+        output: Raw output from `ruff check --output-format json`.
 
     Returns:
-        List of RuffIssue objects
+        list[RuffIssue]: Parsed issues.
     """
     issues: list[RuffIssue] = []
 
-    if not output or output.strip() == "[]":
+    if not output or output.strip() in ("[]", "{}"):
         return issues
 
+    def _int_from(d: dict, candidates: list[str]) -> int | None:
+        for key in candidates:
+            val = d.get(key)
+            if isinstance(val, int):
+                return val
+        return None
+
+    def _parse_item(item: dict) -> RuffIssue | None:
+        try:
+            filename: str = item.get("filename") or item.get("file") or ""
+
+            loc: dict = item.get("location") or item.get("start") or {}
+            end_loc: dict = item.get("end_location") or item.get("end") or {}
+
+            line = _int_from(loc, ["row", "line"]) or 0
+            column = _int_from(loc, ["column", "col"]) or 0
+            end_line = _int_from(end_loc, ["row", "line"]) or line
+            end_column = _int_from(end_loc, ["column", "col"]) or column
+
+            code: str = item.get("code") or item.get("rule") or ""
+            message: str = item.get("message") or ""
+            url: str | None = item.get("url")
+
+            fix = item.get("fix") or {}
+            fixable: bool = bool(fix)
+            fix_applicability = (
+                fix.get("applicability") if isinstance(fix, dict) else None
+            )
+
+            return RuffIssue(
+                file=filename,
+                line=line,
+                column=column,
+                code=code,
+                message=message,
+                url=url,
+                end_line=end_line,
+                end_column=end_column,
+                fixable=fixable,
+                fix_applicability=fix_applicability,
+            )
+        except Exception:
+            return None
+
+    # First try JSON array (with possible trailing non-JSON data)
     try:
-        # Ruff outputs JSON array of issue objects, but may have warnings
-        # after. Find the end of the JSON array by looking for the
-        # closing
-        # bracket
         json_end = output.rfind("]")
-        if json_end == -1:
-            # No closing bracket found, try to parse the whole output
-            ruff_data = json.loads(output)
-        else:
-            # Extract just the JSON part (up to and including the closing bracket)
+        if json_end != -1:
             json_part = output[: json_end + 1]
             ruff_data = json.loads(json_part)
+        else:
+            ruff_data = json.loads(output)
 
-        for item in ruff_data:
-            # Extract fix applicability if available
-            fix_applicability = None
-            if item.get("fix"):
-                fix_applicability = item["fix"].get("applicability")
-
-            issues.append(
-                RuffIssue(
-                    file=item["filename"],
-                    line=item["location"]["row"],
-                    column=item["location"]["column"],
-                    code=item["code"],
-                    message=item["message"],
-                    url=item.get("url"),
-                    end_line=item["end_location"]["row"],
-                    end_column=item["end_location"]["column"],
-                    fixable=bool(item.get("fix")),
-                    fix_applicability=fix_applicability,
-                ),
-            )
-    except (json.JSONDecodeError, KeyError, TypeError):
-        # If JSON parsing fails, return empty list
-        # Could also log the error for debugging
+        if isinstance(ruff_data, list):
+            for item in ruff_data:
+                if not isinstance(item, dict):
+                    continue
+                parsed = _parse_item(item)
+                if parsed is not None:
+                    issues.append(parsed)
+            return issues
+    except (json.JSONDecodeError, TypeError):
+        # Fall back to JSON Lines parsing below
         pass
 
+    # Fallback: parse JSON Lines (each line is a JSON object)
+    for line in output.splitlines():
+        line_str = line.strip()
+        if not line_str or not line_str.startswith("{"):
+            continue
+        try:
+            item = json.loads(line_str)
+            if isinstance(item, dict):
+                parsed = _parse_item(item)
+                if parsed is not None:
+                    issues.append(parsed)
+        except json.JSONDecodeError:
+            continue
+
     return issues
 
 

lintro/parsers/yamllint/yamllint_parser.py

@@ -41,7 +41,7 @@ def parse_yamllint_output(output: str) -> list[YamllintIssue]:
         # Pattern for yamllint parsable format: "filename:line:column: [level]
         # message (rule)"
         pattern: re.Pattern[str] = re.compile(
-            r"^([^:]+):(\d+):(\d+):\s*\[(error|warning)\]\s+(.+?)(?:\s+\(([^)]+)\))?$"
+            r"^([^:]+):(\d+):(\d+):\s*\[(error|warning)\]\s+(.+?)(?:\s+\(([^)]+)\))?$",
         )
 
         match: re.Match[str] | None = pattern.match(line)
@@ -62,7 +62,7 @@ def parse_yamllint_output(output: str) -> list[YamllintIssue]:
                     level=level,
                     rule=rule,
                     message=message.strip(),
-                )
+                ),
             )
 
     return issues

lintro/tools/__init__.py

@@ -4,10 +4,9 @@ from lintro.enums.tool_type import ToolType
 from lintro.models.core.tool import Tool
 from lintro.models.core.tool_config import ToolConfig
 from lintro.tools.core.tool_manager import ToolManager
-
-# Import core implementations after Tool class definition to avoid circular imports
 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
@@ -34,6 +33,7 @@ __all__ = [
     "ToolEnum",
     "tool_manager",
     "AVAILABLE_TOOLS",
+    "BlackTool",
     "ActionlintTool",
     "BanditTool",
     "DarglintTool",

lintro/tools/core/tool_base.py

@@ -61,7 +61,7 @@ class BaseTool(ABC):
 
     _default_timeout: int = DEFAULT_TIMEOUT
     _default_exclude_patterns: list[str] = field(
-        default_factory=lambda: DEFAULT_EXCLUDE_PATTERNS
+        default_factory=lambda: DEFAULT_EXCLUDE_PATTERNS,
     )
 
     def __post_init__(self) -> None:
@@ -256,9 +256,10 @@ class BaseTool(ABC):
     ) -> list[str]:
         """Get the command prefix to execute a tool.
 
-        This method provides common logic for tool executable detection.
-        It first tries to find the tool directly in PATH, and if not found,
-        falls back to running via 'uv run' if uv is available.
+        Prefer running via ``uv run`` when available to ensure the tool executes
+        within the active Python environment, avoiding PATH collisions with
+        user-level shims. Fall back to a direct executable when ``uv`` is not
+        present, and finally to the bare tool name.
 
         Args:
             tool_name: str: Name of the tool executable to find.
@@ -268,20 +269,49 @@ class BaseTool(ABC):
 
         Examples:
             >>> self._get_executable_command("ruff")
-            ["ruff"]  # if ruff is directly available
+            ["uv", "run", "ruff"]  # preferred when uv is available
 
             >>> self._get_executable_command("ruff")
-            ["uv", "run", "ruff"]  # if ruff not available but uv is
+            ["ruff"]  # if uv is not available but the tool is on PATH
         """
-        # First try direct tool execution
-        if shutil.which(tool_name):
+        # Tool-specific preferences to balance reliability vs. historical expectations
+        python_tools_prefer_uv = {"black", "bandit", "yamllint", "darglint"}
+
+        # Ruff: keep historical expectation for tests (direct invocation first)
+        if tool_name == "ruff":
+            if shutil.which(tool_name):
+                return [tool_name]
+            if shutil.which("uv"):
+                return ["uv", "run", tool_name]
+            return [tool_name]
+
+        # Black: prefer system binary first, then project env via uv run,
+        # and finally uvx as a last resort.
+        if tool_name == "black":
+            if shutil.which(tool_name):
+                return [tool_name]
+            if shutil.which("uv"):
+                return ["uv", "run", tool_name]
+            if shutil.which("uvx"):
+                return ["uvx", tool_name]
+            return [tool_name]
+
+        # Python-based tools where running inside env avoids PATH shim issues
+        if tool_name in python_tools_prefer_uv:
+            if shutil.which(tool_name):
+                return [tool_name]
+            if shutil.which("uv"):
+                return ["uv", "run", tool_name]
+            if shutil.which("uvx"):
+                return ["uvx", tool_name]
             return [tool_name]
 
-        # If tool not directly available, try via uv
+        # Default: prefer direct system executable (node/binary tools like
+        # prettier, hadolint, actionlint)
+        if shutil.which(tool_name):
+            return [tool_name]
         if shutil.which("uv"):
             return ["uv", "run", tool_name]
-
-        # Fallback to direct tool (will likely fail but gives clear error)
         return [tool_name]
 
     @abstractmethod

lintro/tools/implementations/tool_bandit.py

@@ -243,13 +243,15 @@ class BanditTool(BaseTool):
         Returns:
             list[str]: List of command arguments.
         """
-        # Prefer system bandit, then `uvx bandit`, then `uv run bandit`.
+        # 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 = self._get_executable_command(tool_name="bandit")
+            exec_cmd = ["bandit"]
 
         cmd: list[str] = exec_cmd + ["-r"]