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

lintro/utils/tool_executor.py

@@ -11,7 +11,7 @@ from lintro.enums.group_by import GroupBy, normalize_group_by
 from lintro.enums.output_format import OutputFormat, normalize_output_format
 from lintro.tools import tool_manager
 from lintro.tools.tool_enum import ToolEnum
-from lintro.utils.config import load_lintro_tool_config
+from lintro.utils.config import load_lintro_tool_config, load_post_checks_config
 from lintro.utils.console_logger import create_logger
 from lintro.utils.output_manager import OutputManager
 from lintro.utils.tool_utils import format_tool_output
@@ -227,6 +227,29 @@ def run_lint_tools_simple(
         # Parse tool options
         tool_option_dict = _parse_tool_options(tool_options)
 
+        # Load post-checks config early to exclude those tools from main phase
+        post_cfg_early = load_post_checks_config()
+        post_enabled_early = bool(post_cfg_early.get("enabled", False))
+        post_tools_early: set[str] = (
+            set(t.lower() for t in (post_cfg_early.get("tools", []) or []))
+            if post_enabled_early
+            else set()
+        )
+
+        if post_tools_early:
+            tools_to_run = [
+                t for t in tools_to_run if t.name.lower() not in post_tools_early
+            ]
+
+        # If early post-check filtering removed all tools from the main phase,
+        # return a failure to signal that nothing was executed in the main run.
+        if not tools_to_run:
+            logger.warning(
+                "All selected tools were filtered out by post-check configuration",
+            )
+            logger.save_console_log()
+            return DEFAULT_EXIT_CODE_FAILURE
+
         # Print main header (skip for JSON mode)
         tools_list: str = ", ".join(t.name.lower() for t in tools_to_run)
         if not json_output_mode:
@@ -252,8 +275,23 @@ def run_lint_tools_simple(
 
         # Run each tool with rich formatting
         for tool_enum in tools_to_run:
-            tool = tool_manager.get_tool(tool_enum)
             tool_name: str = tool_enum.name.lower()
+            # Resolve the tool instance; if unavailable, record failure and continue
+            try:
+                tool = tool_manager.get_tool(tool_enum)
+            except Exception as e:
+                logger.warning(f"Tool '{tool_name}' unavailable: {e}")
+                from lintro.models.core.tool_result import ToolResult
+
+                all_results.append(
+                    ToolResult(
+                        name=tool_name,
+                        success=False,
+                        output=str(e),
+                        issues_count=0,
+                    ),
+                )
+                continue
 
             # Print rich tool header (skip for JSON mode)
             if not json_output_mode:
@@ -281,6 +319,27 @@ def run_lint_tools_simple(
 
                 tool.set_options(include_venv=include_venv)
 
+                # If Black is configured as a post-check, avoid double formatting by
+                # disabling Ruff's formatting stages unless explicitly overridden via
+                # CLI or config. This keeps Ruff focused on lint fixes while Black
+                # handles formatting.
+                if "black" in post_tools_early and tool_name == "ruff":
+                    # Respect explicit overrides from CLI or config
+                    cli_overrides = tool_option_dict.get("ruff", {})
+                    cfg_overrides = cfg or {}
+                    if action == "fmt":
+                        if (
+                            "format" not in cli_overrides
+                            and "format" not in cfg_overrides
+                        ):
+                            tool.set_options(format=False)
+                    else:  # check
+                        if (
+                            "format_check" not in cli_overrides
+                            and "format_check" not in cfg_overrides
+                        ):
+                            tool.set_options(format_check=False)
+
                 # Run the tool
                 logger.debug(f"Executing {tool_name}")
 
@@ -353,18 +412,162 @@ def run_lint_tools_simple(
                     # Pull standardized counts again for debug log
                     fixed_dbg = getattr(result, "fixed_issues_count", fixed_count)
                     remaining_dbg = getattr(
-                        result, "remaining_issues_count", issues_count
+                        result,
+                        "remaining_issues_count",
+                        issues_count,
                     )
                     logger.debug(
                         f"Completed {tool_name}: {fixed_dbg} fixed, "
-                        f"{remaining_dbg} remaining"
+                        f"{remaining_dbg} remaining",
                     )
                 else:
                     logger.debug(f"Completed {tool_name}: {issues_count} issues found")
 
             except Exception as e:
                 logger.error(f"Error running {tool_name}: {e}")
-                return DEFAULT_EXIT_CODE_FAILURE
+                # Record a failure result and continue so that structured output
+                # (e.g., JSON) is still produced even if a tool cannot be
+                # resolved or executed. This keeps behavior consistent with tests
+                # that validate JSON output presence independent of exit codes.
+                from lintro.models.core.tool_result import ToolResult
+
+                all_results.append(
+                    ToolResult(
+                        name=tool_name,
+                        success=False,
+                        output=str(e),
+                        issues_count=0,
+                    ),
+                )
+                # Continue to next tool rather than aborting the entire run
+                continue
+
+        # Optionally run post-checks (explicit, after main tools)
+        post_cfg = post_cfg_early or load_post_checks_config()
+        post_enabled = bool(post_cfg.get("enabled", False))
+        post_tools: list[str] = list(post_cfg.get("tools", [])) if post_enabled else []
+        enforce_failure: bool = bool(post_cfg.get("enforce_failure", action == "check"))
+
+        # In JSON mode, we still need exit-code enforcement even if we skip
+        # rendering post-check outputs. If a post-check tool is unavailable
+        # and enforce_failure is enabled during check, append a failure result
+        # so summaries and exit codes reflect the condition.
+        if post_tools and json_output_mode and action == "check" and enforce_failure:
+            for post_tool_name in post_tools:
+                try:
+                    tool_enum = ToolEnum[post_tool_name.upper()]
+                    # Ensure tool can be resolved; we don't execute it in JSON mode
+                    _ = tool_manager.get_tool(tool_enum)
+                except Exception as e:
+                    from lintro.models.core.tool_result import ToolResult
+
+                    all_results.append(
+                        ToolResult(
+                            name=post_tool_name,
+                            success=False,
+                            output=str(e),
+                            issues_count=1,
+                        ),
+                    )
+
+        if post_tools and not json_output_mode:
+            # Print a clear post-checks section header
+            logger.print_post_checks_header(action=action)
+
+            for post_tool_name in post_tools:
+                try:
+                    tool_enum = ToolEnum[post_tool_name.upper()]
+                except KeyError:
+                    logger.warning(f"Unknown post-check tool: {post_tool_name}")
+                    continue
+
+                # If the tool isn't available in the current environment (e.g., unit
+                # tests that stub a limited set of tools), skip without enforcing
+                # failure. Post-checks are optional when the tool cannot be resolved
+                # from the tool manager.
+                try:
+                    tool = tool_manager.get_tool(tool_enum)
+                except Exception as e:
+                    logger.warning(
+                        f"Post-check '{post_tool_name}' unavailable: {e}",
+                    )
+                    continue
+                tool_name = tool_enum.name.lower()
+
+                # Post-checks run with explicit headers (reuse standard header)
+                if not json_output_mode:
+                    logger.print_tool_header(tool_name=tool_name, action=action)
+
+                try:
+                    # Load tool-specific config and common options
+                    cfg: dict = load_lintro_tool_config(tool_name)
+                    if cfg:
+                        try:
+                            tool.set_options(**cfg)
+                        except Exception as e:
+                            logger.debug(
+                                f"Ignoring invalid config for {tool_name}: {e}",
+                            )
+                    tool.set_options(include_venv=include_venv)
+                    if exclude:
+                        exclude_patterns: list[str] = [
+                            p.strip() for p in exclude.split(",")
+                        ]
+                        tool.set_options(exclude_patterns=exclude_patterns)
+
+                    # For check: Black should run in check mode; for fmt: run fix
+                    if action == "fmt" and tool.can_fix:
+                        result = tool.fix(paths=paths)
+                        issues_count = getattr(result, "issues_count", 0)
+                        total_fixed += getattr(result, "fixed_issues_count", 0) or 0
+                        total_remaining += (
+                            getattr(result, "remaining_issues_count", issues_count) or 0
+                        )
+                    else:
+                        result = tool.check(paths=paths)
+                        issues_count = getattr(result, "issues_count", 0)
+                        total_issues += issues_count
+
+                    # Format and display output
+                    output = getattr(result, "output", None)
+                    issues = getattr(result, "issues", None)
+                    formatted_output: str = ""
+                    if (output and output.strip()) or issues:
+                        formatted_output = format_tool_output(
+                            tool_name=tool_name,
+                            output=output or "",
+                            group_by=group_by_enum.value,
+                            output_format=output_fmt_enum.value,
+                            issues=issues,
+                        )
+
+                    if not json_output_mode:
+                        logger.print_tool_result(
+                            tool_name=tool_name,
+                            output=(output if raw_output else formatted_output),
+                            issues_count=issues_count,
+                            raw_output_for_meta=output,
+                            action=action,
+                            success=getattr(result, "success", None),
+                        )
+
+                    all_results.append(result)
+                except Exception as e:
+                    # Do not crash the entire run due to missing optional post-check
+                    # tool
+                    logger.warning(f"Post-check '{post_tool_name}' failed: {e}")
+                    # Only enforce failure when the tool was available and executed
+                    if enforce_failure and action == "check":
+                        from lintro.models.core.tool_result import ToolResult
+
+                        all_results.append(
+                            ToolResult(
+                                name=post_tool_name,
+                                success=False,
+                                output=str(e),
+                                issues_count=1,
+                            ),
+                        )
 
         # Handle output based on format
         if json_output_mode:
@@ -403,11 +606,15 @@ def run_lint_tools_simple(
                     "issues_count": getattr(result, "issues_count", 0),
                     "output": getattr(result, "output", ""),
                     "initial_issues_count": getattr(
-                        result, "initial_issues_count", None
+                        result,
+                        "initial_issues_count",
+                        None,
                     ),
                     "fixed_issues_count": getattr(result, "fixed_issues_count", None),
                     "remaining_issues_count": getattr(
-                        result, "remaining_issues_count", None
+                        result,
+                        "remaining_issues_count",
+                        None,
                     ),
                 }
                 json_data["results"].append(result_data)

lintro/utils/tool_utils.py

@@ -19,6 +19,10 @@ from lintro.formatters.tools.bandit_formatter import (
     BanditTableDescriptor,
     format_bandit_issues,
 )
+from lintro.formatters.tools.black_formatter import (
+    BlackTableDescriptor,
+    format_black_issues,
+)
 from lintro.formatters.tools.darglint_formatter import (
     DarglintTableDescriptor,
     format_darglint_issues,
@@ -40,6 +44,8 @@ from lintro.formatters.tools.yamllint_formatter import (
     format_yamllint_issues,
 )
 from lintro.parsers.bandit.bandit_parser import parse_bandit_output
+from lintro.parsers.black.black_issue import BlackIssue
+from lintro.parsers.black.black_parser import parse_black_output
 from lintro.parsers.darglint.darglint_parser import parse_darglint_output
 from lintro.parsers.hadolint.hadolint_parser import parse_hadolint_output
 from lintro.parsers.prettier.prettier_issue import PrettierIssue
@@ -52,6 +58,7 @@ from lintro.parsers.yamllint.yamllint_parser import parse_yamllint_output
 TOOL_TABLE_FORMATTERS: dict[str, tuple] = {
     "darglint": (DarglintTableDescriptor(), format_darglint_issues),
     "hadolint": (HadolintTableDescriptor(), format_hadolint_issues),
+    "black": (BlackTableDescriptor(), format_black_issues),
     "prettier": (PrettierTableDescriptor(), format_prettier_issues),
     "ruff": (RuffTableDescriptor(), format_ruff_issues),
     "yamllint": (YamllintTableDescriptor(), format_yamllint_issues),
@@ -301,6 +308,8 @@ def format_tool_output(
                 )
             if tool == "prettier":
                 return lambda i: isinstance(i, PrettierIssue) or True
+            if tool == "black":
+                return lambda i: isinstance(i, BlackIssue) or True
             return None
 
         is_fixable = _is_fixable_predicate(tool_name)
@@ -354,6 +363,8 @@ def format_tool_output(
         parsed_issues = parse_ruff_output(output=output)
     elif tool_name == "prettier":
         parsed_issues = parse_prettier_output(output=output)
+    elif tool_name == "black":
+        parsed_issues = parse_black_output(output=output)
     elif tool_name == "darglint":
         parsed_issues = parse_darglint_output(output=output)
     elif tool_name == "hadolint":
@@ -364,7 +375,7 @@ def format_tool_output(
         # Bandit emits JSON; try parsing when raw output is provided
         try:
             parsed_issues = parse_bandit_output(
-                bandit_data=__import__("json").loads(output)
+                bandit_data=__import__("json").loads(output),
             )
         except Exception:
             parsed_issues = []

{lintro-0.5.2.dist-info → lintro-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lintro
-Version: 0.5.2
+Version: 0.6.0
 Summary: A unified CLI tool for code formatting, linting, and quality assurance
 Author-email: TurboCoder13 <turbocoder13@gmail.com>
 License: MIT License
@@ -49,9 +49,9 @@ Requires-Dist: httpx==0.28.1
 Requires-Dist: toml==0.10.2
 Requires-Dist: defusedxml==0.7.1
 Provides-Extra: dev
-Requires-Dist: pytest==8.4.1; extra == "dev"
+Requires-Dist: pytest==8.4.2; extra == "dev"
 Requires-Dist: pytest-cov==6.2.1; extra == "dev"
-Requires-Dist: pytest-mock==3.14.1; extra == "dev"
+Requires-Dist: pytest-mock==3.15.0; extra == "dev"
 Requires-Dist: pytest-xdist==3.8.0; extra == "dev"
 Requires-Dist: tox==4.30.1; extra == "dev"
 Requires-Dist: allure-pytest==2.15.0; extra == "dev"
@@ -62,9 +62,9 @@ Requires-Dist: python-semantic-release==10.3.1; extra == "dev"
 Requires-Dist: assertpy==1.1; extra == "dev"
 Requires-Dist: httpx==0.28.1; extra == "dev"
 Provides-Extra: test
-Requires-Dist: pytest==8.4.1; extra == "test"
+Requires-Dist: pytest==8.4.2; extra == "test"
 Requires-Dist: pytest-cov==6.2.1; extra == "test"
-Requires-Dist: pytest-mock==3.14.1; extra == "test"
+Requires-Dist: pytest-mock==3.15.0; extra == "test"
 Requires-Dist: pytest-xdist==3.8.0; extra == "test"
 Requires-Dist: assertpy==1.1; extra == "test"
 Provides-Extra: typing
@@ -121,6 +121,7 @@ Lintro is a unified command-line interface that brings together multiple code qu
 | [![Darglint](https://img.shields.io/badge/Darglint-docstrings-3776AB?logo=python&logoColor=white)](https://github.com/terrencepreilly/darglint)     | 🐍 Python           | -        |
 | [![Hadolint](https://img.shields.io/badge/Hadolint-lint-2496ED?logo=docker&logoColor=white)](https://github.com/hadolint/hadolint)                  | 🐳 Dockerfile       | -        |
 | [![Prettier](https://img.shields.io/badge/Prettier-format-1a2b34?logo=prettier&logoColor=white)](https://prettier.io/)                              | 🟨 JS/TS · 🧾 JSON  | ✅       |
+| [![Black](https://img.shields.io/badge/Black-format-000000?logo=python&logoColor=white)](https://github.com/psf/black)                              | 🐍 Python           | ✅       |
 | [![Ruff](https://img.shields.io/badge/Ruff-lint%2Bformat-000?logo=ruff&logoColor=white)](https://github.com/astral-sh/ruff)                         | 🐍 Python           | ✅       |
 | [![Yamllint](https://img.shields.io/badge/Yamllint-lint-cb171e?logo=yaml&logoColor=white)](https://github.com/adrienverge/yamllint)                 | 🧾 YAML             | -        |
 
@@ -216,11 +217,12 @@ lintro check --exclude "migrations,node_modules,dist"
 # Tool-specific options use key=value (lists with |)
 lintro check --tool-options "ruff:line_length=88,prettier:print_width=80"
 
-# Ruff fix configuration (fmt):
-# By default, fmt applies both lint fixes and formatting for Ruff.
-# Disable either stage as needed:
-lintro format --tool-options ruff:lint_fix=False     # format only
-lintro format --tool-options ruff:format=False       # lint fixes only
+# Ruff + Black cooperation:
+# Lintro prefers Ruff for linting and Black for formatting.
+# When Black is configured as a post-check, Lintro disables Ruff formatting by
+# default to avoid double-formatting. Override if needed:
+lintro format --tool-options ruff:format=True        # force Ruff to format
+lintro check  --tool-options ruff:format_check=True  # force Ruff format check
 ```
 
 ### CI/CD Integration

{lintro-0.5.2.dist-info → lintro-0.6.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-lintro/__init__.py,sha256=ZKEhpoNtwjgj6igcxb3k2Eb_9YpjCcvTpfQ5nMtnB7A,110
+lintro/__init__.py,sha256=2iiiR-odH9Z1PRlxA-gFkz8CL2czUJ2VYw88rjeMsmY,110
 lintro/__main__.py,sha256=McxM6wEcEeCLBHZs0F8xzT1PxVqJYkjtaPq1_-Nug-0,106
 lintro/cli.py,sha256=Fy5nqdSg4id0gjGbPy82wRTK3aZMWbRdRDnwAbIv-vs,2333
 lintro/ascii-art/fail.txt,sha256=gshKngSrz5FvJdP6g7lPygpLsLsZZh4etBU_wR7PXOw,56396
@@ -31,9 +31,10 @@ lintro/formatters/styles/json.py,sha256=aZobZxntAiyo92_elI1VznrOd8jzEPrU7MUQBQHd
 lintro/formatters/styles/markdown.py,sha256=proUn2UEhNceTw6mVv_KSBYinLekgATx58ZWiu_PT1U,1309
 lintro/formatters/styles/plain.py,sha256=_-4ziK6vBtvxI1wk-qLJHqKTUMs0SGWaBJPz1zV4Ngc,1125
 lintro/formatters/tools/__init__.py,sha256=5HxvLscHFl-dYv0h_X6_-rEaszdVU-XPNtL-ZkliGvU,1289
-lintro/formatters/tools/actionlint_formatter.py,sha256=VtwwGSSsTxmWTy-w9U2Mtu0X_Pmg7rarS4tV7G1nq90,2811
-lintro/formatters/tools/bandit_formatter.py,sha256=iuLAHX08cP6gC6kLqJzlGMjtSRgYXjhwycfKiy4lBtg,3092
-lintro/formatters/tools/darglint_formatter.py,sha256=kik3kJM1eENOSEVWzUXBZYUeBOCB3FjZcFUns0HL0ck,2177
+lintro/formatters/tools/actionlint_formatter.py,sha256=GiUlD7DSW375seiPNLwdX3mOjtcn56T7z7ho4nQzEz8,2812
+lintro/formatters/tools/bandit_formatter.py,sha256=WP7haIWGjIPuGZf1FQ5Ixi5DKIySHGdX-L7hZcKnFuw,3093
+lintro/formatters/tools/black_formatter.py,sha256=xFmcmdfgQributNqQRBtp7MwPfR6QKFCsBo6urk0tDY,1623
+lintro/formatters/tools/darglint_formatter.py,sha256=NG5V32PX7PnxOccisyXYy02TVUp15r1dzwZzC9KQRsw,2202
 lintro/formatters/tools/hadolint_formatter.py,sha256=enugwgR571IFv-75HJ-RCrsK9GBZfH-Bwb-WjoJGd2Y,2608
 lintro/formatters/tools/prettier_formatter.py,sha256=VtV3uSoNhUtatqQa18QtQgcBAmzMPyjS2xDIAzpI0IY,2470
 lintro/formatters/tools/ruff_formatter.py,sha256=3R3ByBDN5YzR71cLOyNQMWLDkVU8qif_PweoTQXskkM,4011
@@ -47,46 +48,49 @@ lintro/parsers/__init__.py,sha256=53UA1LuS21BL4xj8i81Qb59dKXe3jCFLBrDVqvvNHVQ,28
 lintro/parsers/actionlint/__init__.py,sha256=N953d0kbJEOZE9cG4eq9BjiSErdk10GMrngV_tKjLvo,33
 lintro/parsers/actionlint/actionlint_issue.py,sha256=H_BQr04KAGHpVp1qKqETcWLi3i-u6atl7ccDae-jqX8,636
 lintro/parsers/actionlint/actionlint_parser.py,sha256=FAovzY877UeaDj7ZHb0zy6Y_hsidWS6UR1O8KCYVISU,1889
+lintro/parsers/black/black_issue.py,sha256=RwrT7n8aw4Nybakv83eXoeUxZlDtHwicWKNfrHYIYOg,507
+lintro/parsers/black/black_parser.py,sha256=mCbEy4aTRtxC_SKKPNK6hThGEu8C0m9EnliFW__Sa3Y,2958
 lintro/parsers/darglint/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lintro/parsers/darglint/darglint_issue.py,sha256=f43blLSM13r1VyyGwk-bjtC7raBCjRqwlnPw7Nmx9ic,127
-lintro/parsers/darglint/darglint_parser.py,sha256=oh2Q-innmm_H5O-xTNMvObmLMFJSL51uqOtSgG39WsQ,2045
+lintro/parsers/darglint/darglint_parser.py,sha256=pbIGnmHVKjf8OaxvhQbDWWXAFZEictb3FfuhoGv_I00,2046
 lintro/parsers/hadolint/__init__.py,sha256=vU33M_cj6fyg7aqZthz8MFUMfBIshX_Nx3DNuQmbHD4,30
 lintro/parsers/hadolint/hadolint_issue.py,sha256=VlTzTPHcluFZihFL-Tkg7UuXp1fQcD03eDCH0sr1qHU,582
-lintro/parsers/hadolint/hadolint_parser.py,sha256=KMWlHI6ulfseWCcPrvLHKa6ONkQj4zKHqPvy0Q7Nu9M,1808
+lintro/parsers/hadolint/hadolint_parser.py,sha256=Q7Hf6sL45s38O3C9dbBYzOpDlb0KGFj0U3Yry_ixdK8,1810
 lintro/parsers/prettier/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lintro/parsers/prettier/prettier_issue.py,sha256=yeOUmkb79mhYmidcx-iZgxvsNl_jkjT3ZCqT_Vo27rw,164
 lintro/parsers/prettier/prettier_parser.py,sha256=lH50rhFHbWWLH50CiTlyIvjgbx9vz1hiIdtxEXi7uJw,2043
 lintro/parsers/ruff/__init__.py,sha256=1oT00c82qKfveRqa4FnSedAEQjQVrb9BspJEUQJn-Kk,26
 lintro/parsers/ruff/ruff_issue.py,sha256=96ht6YWImOBiRTo0ATlM1PvVhgIwFiuN8810emm9nXo,1142
-lintro/parsers/ruff/ruff_parser.py,sha256=dvufb9F2JLBfdHE2houF5M-5tDcKRsEhtC1CBNww0L8,2919
+lintro/parsers/ruff/ruff_parser.py,sha256=dwNaDgb-96DPuIiAgtHa0E1lTtzr2FLeWdZD_LVZhxE,4576
 lintro/parsers/yamllint/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lintro/parsers/yamllint/yamllint_issue.py,sha256=jWawdGUiTI1HADbhg8yEdZfC6yHcmk9FDzpr3PBUPBg,608
-lintro/parsers/yamllint/yamllint_parser.py,sha256=UaZ0sjVPUw3kWJ7QYHY0wX9ybifoy1NbicGjBDMijGE,1945
-lintro/tools/__init__.py,sha256=8prHy3TTttzVvWWzn5xbPRHwXkPoN6P_KGqTmFJh5HI,1416
-lintro/tools/tool_enum.py,sha256=kQ7atS2ZrfhiEgRJtjPAM4zn0PVhK9iObEqJj0no3JI,767
+lintro/parsers/yamllint/yamllint_parser.py,sha256=ol44xhJcspnGIsEta8vVv1xi-sIbpB12CovmT94QFmQ,1947
+lintro/tools/__init__.py,sha256=S-L_x7Hzp-Ja-QezupEUwF6-uhRl4ZXSIpRx59jvsaA,1410
+lintro/tools/tool_enum.py,sha256=ECok554KLqeLuU2xyLl1fcqzh77x9ojc-6Z7CRBRQUU,851
 lintro/tools/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lintro/tools/core/tool_base.py,sha256=FIotjOzpE3E2fK2t2gA4c6Pwe7AI3uc2GF0-wpe13o4,11043
+lintro/tools/core/tool_base.py,sha256=pnu1sMwPuICCOy_CZRip6HhvHVSYfs7q5Sfpi9zUX9E,12360
 lintro/tools/core/tool_manager.py,sha256=yKQONy17t7-fq1k9dkrMk6lZaAvaSwp7-JcvJFZMoYc,5103
 lintro/tools/implementations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lintro/tools/implementations/tool_actionlint.py,sha256=7b1pUxs9Ln6KmoLiRQBmyDeq9SmgZ08e0DxleM9NEt8,5466
-lintro/tools/implementations/tool_bandit.py,sha256=Iw6ekDayg8JdSD8dLDOlaUtQ4adcd83wp1iF4xeiteI,15823
+lintro/tools/implementations/tool_bandit.py,sha256=Ck1fT8I9CSRTJ8zYqXYsVMQ_-HSp_VzUcB6GWuTahvI,15939
+lintro/tools/implementations/tool_black.py,sha256=x1U6NhdRxxYE5Tmvh-LoxcWtIkwHceeJWMUROa9tAJ4,9680
 lintro/tools/implementations/tool_darglint.py,sha256=zj8hQ8bVW3fwO8dsK9tdXzyL1yzZvqiEetVGvxhGe4g,9396
 lintro/tools/implementations/tool_hadolint.py,sha256=NfHLoThp23V-n5chSfrBZetleXsRR4oYxkLxOkJxU0g,11479
-lintro/tools/implementations/tool_prettier.py,sha256=QTboRboHLRzhgGdpGnRbaFf2D2DaG981iRWFYvTUfJE,9446
-lintro/tools/implementations/tool_ruff.py,sha256=l8QVQES8mvY7pceP0aLS2ivzOsTWmyika6D6eXGnvqs,24424
+lintro/tools/implementations/tool_prettier.py,sha256=ecpeG0sqbTRIQ5KziiwN8gmlPzoKHebdC2AkEKHUWrk,9447
+lintro/tools/implementations/tool_ruff.py,sha256=8WIpOKSc6HmuvEFCWgTqBX9X4T3MSD-RKesv4bs2lpQ,25361
 lintro/tools/implementations/tool_yamllint.py,sha256=0powR9F3FkIq-b7PI0-XWdh7nx7rR3HVMtvEaz_NWeA,8831
 lintro/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lintro/utils/ascii_normalize_cli.py,sha256=ztuHEvmMgl2gLy3vAo8RTwvxCTWyXgL1C7jPMX7IaKM,2391
-lintro/utils/config.py,sha256=Mi_3dqPjmNF7pcgA3b-Dx0CKQe_qrYCh_uYF9u6g0TQ,1036
-lintro/utils/console_logger.py,sha256=1WPIsKySvd6kPcAa4JyqtAd3G8lJf4MOcR1AzGk8TmI,31483
+lintro/utils/ascii_normalize_cli.py,sha256=8Pi9XHIIIYCyPCq-JOAPnj5tYbz6XLmFLO7KypCv3EA,2408
+lintro/utils/config.py,sha256=3AVwNAteT-enN6Ica8jJbPwEFO94i4F7uWiEA1HSpJY,1427
+lintro/utils/console_logger.py,sha256=N0n5LomG6MDqu4tSPbmhBsIB6lzpRl5M53tZx6EoF4k,33104
 lintro/utils/formatting.py,sha256=khC9hYBva5xqBV1IqNcivRH9gRdvWw6u6mh2TZLTy7E,5346
-lintro/utils/output_manager.py,sha256=kqTlWcR2HXyo-uiiWypHm8XaG8DQnngWgEqf1H9X5DU,10211
+lintro/utils/output_manager.py,sha256=oIE0g8LNVQcWSQOb1MbDVqGYPrOjBGuUZ4R80M1RevQ,10213
 lintro/utils/path_utils.py,sha256=NJP3vjVDcRBgUHtYNrpL0tRa0Sc3oQhGX3_2WWzdZE4,1395
-lintro/utils/tool_executor.py,sha256=daY1ueIhOmXCEb1Jf56F7gj_UO8yKtTZ9zqxiQKmEj8,16535
-lintro/utils/tool_utils.py,sha256=dspPnkNwYBtVbV2NDiBHEpq3-zsOVFj4szipdvoDxY0,15407
-lintro-0.5.2.dist-info/licenses/LICENSE,sha256=CwaAnyD2psonDBBJjbqFUz00W8nQw-FGDlEGZReUV6A,1069
-lintro-0.5.2.dist-info/METADATA,sha256=kyXWPb_kExrKV47NqwarEYAeXBBDrOA0sZbP_6-2VeE,13584
-lintro-0.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lintro-0.5.2.dist-info/entry_points.txt,sha256=SYSk35jFyNLEHyrofSJsRv4qFN9NsT4VWSbvnTS9ov0,43
-lintro-0.5.2.dist-info/top_level.txt,sha256=_D-7eyV6gNBOoIwHuf_h60wN_RWiw8GxB430Il9VKhU,7
-lintro-0.5.2.dist-info/RECORD,,
+lintro/utils/tool_executor.py,sha256=8-m7nQKLRlKHBTvzT7iLmaHYZ3-2s0t4zUbC-py8-H8,26204
+lintro/utils/tool_utils.py,sha256=zobweCIANBxXxHUERajFDshQyZGlEnJPQ52NleOrDdQ,15884
+lintro-0.6.0.dist-info/licenses/LICENSE,sha256=CwaAnyD2psonDBBJjbqFUz00W8nQw-FGDlEGZReUV6A,1069
+lintro-0.6.0.dist-info/METADATA,sha256=OJJqMjydyyG24aRGue4W3yGQHDSP-qAYsS7hKNkC674,13881
+lintro-0.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lintro-0.6.0.dist-info/entry_points.txt,sha256=SYSk35jFyNLEHyrofSJsRv4qFN9NsT4VWSbvnTS9ov0,43
+lintro-0.6.0.dist-info/top_level.txt,sha256=_D-7eyV6gNBOoIwHuf_h60wN_RWiw8GxB430Il9VKhU,7
+lintro-0.6.0.dist-info/RECORD,,