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

lintro/utils/tool_executor.py

@@ -11,16 +11,67 @@ 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, load_post_checks_config
+from lintro.utils.config import 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
+from lintro.utils.unified_config import UnifiedConfigManager
 
 # Constants
 DEFAULT_EXIT_CODE_SUCCESS: int = 0
 DEFAULT_EXIT_CODE_FAILURE: int = 1
 DEFAULT_REMAINING_COUNT: int = 1
 
+# Mapping from ToolEnum to canonical display names
+_TOOL_DISPLAY_NAMES: dict[ToolEnum, str] = {
+    ToolEnum.BLACK: "black",
+    ToolEnum.DARGLINT: "darglint",
+    ToolEnum.HADOLINT: "hadolint",
+    ToolEnum.PRETTIER: "prettier",
+    ToolEnum.PYTEST: "pytest",
+    ToolEnum.RUFF: "ruff",
+    ToolEnum.YAMLLINT: "yamllint",
+    ToolEnum.ACTIONLINT: "actionlint",
+    ToolEnum.BANDIT: "bandit",
+}
+
+
+def _get_tool_display_name(tool_enum: ToolEnum) -> str:
+    """Get the canonical display name for a tool enum.
+
+    This function provides a consistent mapping from ToolEnum to user-friendly
+    display names. It first attempts to get the tool instance to use its canonical
+    name, but falls back to a predefined mapping if the tool cannot be instantiated.
+
+    Args:
+        tool_enum: The ToolEnum instance.
+
+    Returns:
+        str: The canonical display name for the tool.
+    """
+    # Try to get the tool instance to use its canonical name
+    try:
+        tool = tool_manager.get_tool(tool_enum)
+        return tool.name
+    except Exception:
+        # Fall back to predefined mapping if tool cannot be instantiated
+        return _TOOL_DISPLAY_NAMES.get(tool_enum, tool_enum.name.lower())
+
+
+def _get_tool_lookup_keys(tool_enum: ToolEnum, tool_name: str) -> set[str]:
+    """Get all possible lookup keys for a tool in tool_option_dict.
+
+    This includes the tool's display name and enum name (both lowercased).
+
+    Args:
+        tool_enum: The ToolEnum instance.
+        tool_name: The canonical display name for the tool.
+
+    Returns:
+        set[str]: Set of lowercase keys to check in tool_option_dict.
+    """
+    return {tool_name.lower(), tool_enum.name.lower()}
+
 
 def _get_tools_to_run(
     tools: str | None,
@@ -30,7 +81,7 @@ def _get_tools_to_run(
 
     Args:
         tools: str | None: Comma-separated tool names, "all", or None.
-        action: str: "check" or "fmt".
+        action: str: "check", "fmt", or "test".
 
     Returns:
         list[ToolEnum]: List of ToolEnum instances to run.
@@ -38,19 +89,43 @@ def _get_tools_to_run(
     Raises:
         ValueError: If unknown tool names are provided.
     """
+    if action == "test":
+        # Test action only supports pytest
+        if tools and tools.lower() != "pytest":
+            raise ValueError(
+                (
+                    "Only 'pytest' is supported for the test action; "
+                    "run 'lintro test' without --tools or "
+                    "use '--tools pytest'"
+                ),
+            )
+        try:
+            return [ToolEnum["PYTEST"]]
+        except KeyError:
+            raise ValueError(
+                "pytest tool is not available",
+            ) from None
+
     if tools == "all" or tools is None:
         # Get all available tools for the action
         if action == "fmt":
             available_tools = tool_manager.get_fix_tools()
         else:  # check
             available_tools = tool_manager.get_check_tools()
-        return list(available_tools.keys())
+        # Filter out pytest for check/fmt actions
+        return [t for t in available_tools if t.name.upper() != "PYTEST"]
 
     # Parse specific tools
     tool_names: list[str] = [name.strip().upper() for name in tools.split(",")]
     tools_to_run: list[ToolEnum] = []
 
     for name in tool_names:
+        # Reject pytest for check/fmt actions
+        if name == "PYTEST":
+            raise ValueError(
+                "pytest tool is not available for check/fmt actions. "
+                "Use 'lintro test' instead.",
+            )
         try:
             tool_enum = ToolEnum[name]
             # Verify the tool supports the requested action
@@ -62,7 +137,9 @@ def _get_tools_to_run(
                     )
             tools_to_run.append(tool_enum)
         except KeyError:
-            available_names: list[str] = [e.name.lower() for e in ToolEnum]
+            available_names: list[str] = [
+                e.name.lower() for e in ToolEnum if e.name.upper() != "PYTEST"
+            ]
             raise ValueError(
                 f"Unknown tool '{name.lower()}'. Available tools: {available_names}",
             ) from None
@@ -144,7 +221,7 @@ def _parse_tool_options(tool_options: str | None) -> dict[str, dict[str, object]
             # Skip malformed fragment
             continue
         opt_name, opt_value = tool_opt.split("=", 1)
-        tool_name = tool_name.strip()
+        tool_name = tool_name.strip().lower()
         opt_name = opt_name.strip()
         opt_value = opt_value.strip()
         if not tool_name or not opt_name:
@@ -156,6 +233,189 @@ def _parse_tool_options(tool_options: str | None) -> dict[str, dict[str, object]
     return tool_option_dict
 
 
+def _write_output_file(
+    *,
+    output_path: str,
+    output_format: OutputFormat,
+    all_results: list,
+    action: str,
+    total_issues: int,
+    total_fixed: int,
+) -> None:
+    """Write results to user-specified output file.
+
+    Args:
+        output_path: str: Path to the output file.
+        output_format: OutputFormat: Format for the output.
+        all_results: list: List of ToolResult objects.
+        action: str: The action performed (check, fmt, test).
+        total_issues: int: Total number of issues found.
+        total_fixed: int: Total number of issues fixed.
+    """
+    import csv
+    import datetime
+    import json
+    from pathlib import Path
+
+    output_file = Path(output_path)
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+
+    if output_format == OutputFormat.JSON:
+        # Build JSON structure similar to stdout JSON mode
+        json_data = {
+            "timestamp": datetime.datetime.now().isoformat(),
+            "action": action,
+            "summary": {
+                "total_issues": total_issues,
+                "total_fixed": total_fixed,
+                "tools_run": len(all_results),
+            },
+            "results": [],
+        }
+        for result in all_results:
+            result_data = {
+                "tool": result.name,
+                "success": getattr(result, "success", True),
+                "issues_count": getattr(result, "issues_count", 0),
+                "output": getattr(result, "output", ""),
+            }
+            if hasattr(result, "issues") and result.issues:
+                result_data["issues"] = [
+                    {
+                        "file": getattr(issue, "file", ""),
+                        "line": getattr(issue, "line", ""),
+                        "code": getattr(issue, "code", ""),
+                        "message": getattr(issue, "message", ""),
+                    }
+                    for issue in result.issues
+                ]
+            json_data["results"].append(result_data)
+        output_file.write_text(
+            json.dumps(json_data, indent=2, ensure_ascii=False),
+            encoding="utf-8",
+        )
+
+    elif output_format == OutputFormat.CSV:
+        # Write CSV format
+        rows: list[list[str]] = []
+        header: list[str] = ["tool", "issues_count", "file", "line", "code", "message"]
+        for result in all_results:
+            if hasattr(result, "issues") and result.issues:
+                for issue in result.issues:
+                    rows.append(
+                        [
+                            result.name,
+                            str(getattr(result, "issues_count", 0)),
+                            str(getattr(issue, "file", "")),
+                            str(getattr(issue, "line", "")),
+                            str(getattr(issue, "code", "")),
+                            str(getattr(issue, "message", "")),
+                        ],
+                    )
+            else:
+                rows.append(
+                    [
+                        result.name,
+                        str(getattr(result, "issues_count", 0)),
+                        "",
+                        "",
+                        "",
+                        "",
+                    ],
+                )
+        with output_file.open("w", encoding="utf-8", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerow(header)
+            writer.writerows(rows)
+
+    elif output_format == OutputFormat.MARKDOWN:
+        # Write Markdown format
+        lines: list[str] = ["# Lintro Report", ""]
+        lines.append("## Summary\n")
+        lines.append("| Tool | Issues |")
+        lines.append("|------|--------|")
+        for result in all_results:
+            lines.append(f"| {result.name} | {getattr(result, 'issues_count', 0)} |")
+        lines.append("")
+        for result in all_results:
+            issues_count = getattr(result, "issues_count", 0)
+            lines.append(f"### {result.name} ({issues_count} issues)")
+            if hasattr(result, "issues") and result.issues:
+                lines.append("| File | Line | Code | Message |")
+                lines.append("|------|------|------|---------|")
+                for issue in result.issues:
+                    file_val = str(getattr(issue, "file", "")).replace("|", r"\|")
+                    line_val = getattr(issue, "line", "")
+                    code_val = str(getattr(issue, "code", "")).replace("|", r"\|")
+                    msg_val = str(getattr(issue, "message", "")).replace("|", r"\|")
+                    lines.append(
+                        f"| {file_val} | {line_val} | {code_val} | {msg_val} |",
+                    )
+                lines.append("")
+            else:
+                lines.append("No issues found.\n")
+        output_file.write_text("\n".join(lines), encoding="utf-8")
+
+    elif output_format == OutputFormat.HTML:
+        # Write HTML format
+        html_lines: list[str] = [
+            "<html><head><title>Lintro Report</title></head><body>",
+        ]
+        html_lines.append("<h1>Lintro Report</h1>")
+        html_lines.append("<h2>Summary</h2>")
+        html_lines.append("<table border='1'><tr><th>Tool</th><th>Issues</th></tr>")
+        for result in all_results:
+            import html
+
+            safe_name = html.escape(result.name)
+            html_lines.append(
+                f"<tr><td>{safe_name}</td>"
+                f"<td>{getattr(result, 'issues_count', 0)}</td></tr>",
+            )
+        html_lines.append("</table>")
+        for result in all_results:
+            import html
+
+            issues_count = getattr(result, "issues_count", 0)
+            html_lines.append(
+                f"<h3>{html.escape(result.name)} ({issues_count} issues)</h3>",
+            )
+            if hasattr(result, "issues") and result.issues:
+                html_lines.append(
+                    "<table border='1'><tr><th>File</th><th>Line</th>"
+                    "<th>Code</th><th>Message</th></tr>",
+                )
+                for issue in result.issues:
+                    f_val = html.escape(str(getattr(issue, "file", "")))
+                    l_val = getattr(issue, "line", "")
+                    c_val = html.escape(str(getattr(issue, "code", "")))
+                    m_val = html.escape(str(getattr(issue, "message", "")))
+                    html_lines.append(
+                        f"<tr><td>{f_val}</td><td>{l_val}</td>"
+                        f"<td>{c_val}</td><td>{m_val}</td></tr>",
+                    )
+                html_lines.append("</table>")
+            else:
+                html_lines.append("<p>No issues found.</p>")
+        html_lines.append("</body></html>")
+        output_file.write_text("\n".join(html_lines), encoding="utf-8")
+
+    else:
+        # Plain or Grid format - write formatted text output
+        lines: list[str] = [f"Lintro {action.capitalize()} Report", "=" * 40, ""]
+        for result in all_results:
+            issues_count = getattr(result, "issues_count", 0)
+            lines.append(f"{result.name}: {issues_count} issues")
+            output_text = getattr(result, "output", "")
+            if output_text and output_text.strip():
+                lines.append(output_text.strip())
+            lines.append("")
+        lines.append(f"Total Issues: {total_issues}")
+        if action == "fmt":
+            lines.append(f"Total Fixed: {total_fixed}")
+        output_file.write_text("\n".join(lines), encoding="utf-8")
+
+
 def run_lint_tools_simple(
     *,
     action: str,
@@ -168,6 +428,7 @@ def run_lint_tools_simple(
     output_format: str,
     verbose: bool,
     raw_output: bool = False,
+    output_file: str | None = None,
 ) -> int:
     """Simplified runner using Loguru-based logging with rich formatting.
 
@@ -188,6 +449,7 @@ def run_lint_tools_simple(
         output_format: str: Output format for results.
         verbose: bool: Whether to enable verbose output.
         raw_output: bool: Whether to show raw tool output instead of formatted output.
+        output_file: str | None: Optional file path to write results to.
 
     Returns:
         int: Exit code (0 for success, 1 for failures).
@@ -275,11 +537,11 @@ def run_lint_tools_simple(
 
         # Run each tool with rich formatting
         for tool_enum in tools_to_run:
-            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:
+                tool_name: str = _get_tool_display_name(tool_enum)
                 logger.warning(f"Tool '{tool_name}' unavailable: {e}")
                 from lintro.models.core.tool_result import ToolResult
 
@@ -293,22 +555,30 @@ def run_lint_tools_simple(
                 )
                 continue
 
+            # Use canonical display name for consistent logging
+            tool_name: str = _get_tool_display_name(tool_enum)
             # Print rich tool header (skip for JSON mode)
             if not json_output_mode:
                 logger.print_tool_header(tool_name=tool_name, action=action)
 
             try:
-                # Configure tool options
-                # 1) Load config from pyproject.toml / lintro.toml
-                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}")
-                # 2) CLI --tool-options overrides config file
-                if tool_name in tool_option_dict:
-                    tool.set_options(**tool_option_dict[tool_name])
+                # Configure tool options using UnifiedConfigManager
+                # Priority: CLI --tool-options > [tool.lintro.<tool>] > global settings
+                config_manager = UnifiedConfigManager()
+
+                # Build CLI overrides from --tool-options
+                cli_overrides: dict[str, object] = {}
+                lookup_keys = _get_tool_lookup_keys(tool_enum, tool_name)
+                for option_key in lookup_keys:
+                    overrides = tool_option_dict.get(option_key)
+                    if overrides:
+                        cli_overrides.update(overrides)
+
+                # Apply unified config with CLI overrides
+                config_manager.apply_config_to_tool(
+                    tool=tool,
+                    cli_overrides=cli_overrides if cli_overrides else None,
+                )
 
                 # Set common options
                 if exclude:
@@ -324,19 +594,19 @@ def run_lint_tools_simple(
                 # 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 {}
+                    # Get tool config from manager to check for explicit overrides
+                    tool_config = config_manager.get_tool_config(tool_name)
+                    lintro_tool_cfg = tool_config.lintro_tool_config or {}
                     if action == "fmt":
                         if (
                             "format" not in cli_overrides
-                            and "format" not in cfg_overrides
+                            and "format" not in lintro_tool_cfg
                         ):
                             tool.set_options(format=False)
                     else:  # check
                         if (
                             "format_check" not in cli_overrides
-                            and "format_check" not in cfg_overrides
+                            and "format_check" not in lintro_tool_cfg
                         ):
                             tool.set_options(format_check=False)
 
@@ -440,10 +710,15 @@ def run_lint_tools_simple(
                 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"))
+        # Skip post-checks for test action - test commands should only run tests
+        if action == "test":
+            post_tools = []
+            enforce_failure = False
+        else:
+            post_cfg = post_cfg_early or load_post_checks_config()
+            post_enabled = bool(post_cfg.get("enabled", False))
+            post_tools = list(post_cfg.get("tools", [])) if post_enabled else []
+            enforce_failure = 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
@@ -489,22 +764,19 @@ def run_lint_tools_simple(
                         f"Post-check '{post_tool_name}' unavailable: {e}",
                     )
                     continue
-                tool_name = tool_enum.name.lower()
+                # Use canonical display name for consistent logging
+                tool_name = _get_tool_display_name(tool_enum)
 
                 # 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}",
-                            )
+                    # Configure post-check tool using UnifiedConfigManager
+                    # This replaces manual sync logic with unified config management
+                    post_config_manager = UnifiedConfigManager()
+                    post_config_manager.apply_config_to_tool(tool=tool)
+
                     tool.set_options(include_venv=include_venv)
                     if exclude:
                         exclude_patterns: list[str] = [
@@ -630,11 +902,36 @@ def run_lint_tools_simple(
             # Log at debug to avoid failing the run for non-critical persistence.
             logger.debug(f"Error saving outputs: {e}")
 
+        # Write to user-specified output file if provided
+        if output_file:
+            try:
+                _write_output_file(
+                    output_path=output_file,
+                    output_format=output_fmt_enum,
+                    all_results=all_results,
+                    action=action,
+                    total_issues=total_issues,
+                    total_fixed=total_fixed,
+                )
+                logger.debug(f"Wrote results to {output_file}")
+            except Exception as e:
+                logger.error(f"Failed to write output to {output_file}: {e}")
+
         # Return appropriate exit code
         if action == "fmt":
-            # Format operations succeed if they complete successfully
-            # (even if there are remaining unfixable issues)
-            return DEFAULT_EXIT_CODE_SUCCESS
+            # Format operations should fail if:
+            # 1. Any tool reported failure (execution error)
+            # 2. There are remaining unfixable issues after formatting
+            any_failed: bool = any(
+                not getattr(result, "success", True) for result in all_results
+            )
+            # Check if there are remaining issues that couldn't be fixed
+            has_remaining_issues: bool = total_remaining > 0
+            return (
+                DEFAULT_EXIT_CODE_SUCCESS
+                if (not any_failed and not has_remaining_issues)
+                else DEFAULT_EXIT_CODE_FAILURE
+            )
         else:  # check
             # Check operations fail if issues are found OR any tool reported failure
             any_failed: bool = any(

lintro/utils/tool_utils.py

@@ -27,14 +27,26 @@ from lintro.formatters.tools.darglint_formatter import (
     DarglintTableDescriptor,
     format_darglint_issues,
 )
+from lintro.formatters.tools.eslint_formatter import (
+    EslintTableDescriptor,
+    format_eslint_issues,
+)
 from lintro.formatters.tools.hadolint_formatter import (
     HadolintTableDescriptor,
     format_hadolint_issues,
 )
+from lintro.formatters.tools.markdownlint_formatter import (
+    MarkdownlintTableDescriptor,
+    format_markdownlint_issues,
+)
 from lintro.formatters.tools.prettier_formatter import (
     PrettierTableDescriptor,
     format_prettier_issues,
 )
+from lintro.formatters.tools.pytest_formatter import (
+    PytestFailuresTableDescriptor,
+    format_pytest_issues,
+)
 from lintro.formatters.tools.ruff_formatter import (
     RuffTableDescriptor,
     format_ruff_issues,
@@ -47,9 +59,13 @@ 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.eslint.eslint_issue import EslintIssue
+from lintro.parsers.eslint.eslint_parser import parse_eslint_output
 from lintro.parsers.hadolint.hadolint_parser import parse_hadolint_output
+from lintro.parsers.markdownlint.markdownlint_parser import parse_markdownlint_output
 from lintro.parsers.prettier.prettier_issue import PrettierIssue
 from lintro.parsers.prettier.prettier_parser import parse_prettier_output
+from lintro.parsers.pytest.pytest_parser import parse_pytest_text_output
 from lintro.parsers.ruff.ruff_issue import RuffFormatIssue, RuffIssue
 from lintro.parsers.ruff.ruff_parser import parse_ruff_output
 from lintro.parsers.yamllint.yamllint_parser import parse_yamllint_output
@@ -57,13 +73,16 @@ from lintro.parsers.yamllint.yamllint_parser import parse_yamllint_output
 # Constants
 TOOL_TABLE_FORMATTERS: dict[str, tuple] = {
     "darglint": (DarglintTableDescriptor(), format_darglint_issues),
+    "eslint": (EslintTableDescriptor(), format_eslint_issues),
     "hadolint": (HadolintTableDescriptor(), format_hadolint_issues),
     "black": (BlackTableDescriptor(), format_black_issues),
     "prettier": (PrettierTableDescriptor(), format_prettier_issues),
+    "pytest": (PytestFailuresTableDescriptor(), format_pytest_issues),
     "ruff": (RuffTableDescriptor(), format_ruff_issues),
     "yamllint": (YamllintTableDescriptor(), format_yamllint_issues),
     "actionlint": (ActionlintTableDescriptor(), format_actionlint_issues),
     "bandit": (BanditTableDescriptor(), format_bandit_issues),
+    "markdownlint": (MarkdownlintTableDescriptor(), format_markdownlint_issues),
 }
 VENV_PATTERNS: list[str] = [
     "venv",
@@ -304,9 +323,19 @@ def format_tool_output(
                     isinstance(i, RuffIssue) and getattr(i, "fixable", False)
                 )
             if tool == "prettier":
-                return lambda i: isinstance(i, PrettierIssue) or True
+                return lambda i: isinstance(i, PrettierIssue)
             if tool == "black":
-                return lambda i: isinstance(i, BlackIssue) or True
+                return lambda i: isinstance(i, BlackIssue) and getattr(
+                    i,
+                    "fixable",
+                    True,
+                )
+            if tool == "eslint":
+                return lambda i: isinstance(i, EslintIssue) and getattr(
+                    i,
+                    "fixable",
+                    False,
+                )
             return None
 
         is_fixable = _is_fixable_predicate(tool_name)
@@ -364,10 +393,14 @@ def format_tool_output(
         parsed_issues = parse_black_output(output=output)
     elif tool_name == "darglint":
         parsed_issues = parse_darglint_output(output=output)
+    elif tool_name == "eslint":
+        parsed_issues = parse_eslint_output(output=output)
     elif tool_name == "hadolint":
         parsed_issues = parse_hadolint_output(output=output)
     elif tool_name == "yamllint":
         parsed_issues = parse_yamllint_output(output=output)
+    elif tool_name == "markdownlint":
+        parsed_issues = parse_markdownlint_output(output=output)
     elif tool_name == "bandit":
         # Bandit emits JSON; try parsing when raw output is provided
         try:
@@ -376,6 +409,9 @@ def format_tool_output(
             )
         except Exception:
             parsed_issues = []
+    elif tool_name == "pytest":
+        # Pytest emits text output; parse it
+        parsed_issues = parse_pytest_text_output(output=output)
 
     if parsed_issues and tool_name in TOOL_TABLE_FORMATTERS:
         _, formatter_func = TOOL_TABLE_FORMATTERS[tool_name]