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

lintro/utils/console_logger.py

@@ -17,10 +17,12 @@ from lintro.utils.formatting import read_ascii_art
 TOOL_EMOJIS: dict[str, str] = {
     "ruff": "🦀",
     "prettier": "💅",
+    "eslint": "🔍",
     "darglint": "📝",
     "hadolint": "🐳",
     "yamllint": "📄",
     "black": "🖤",
+    "pytest": "🧪",
 }
 DEFAULT_EMOJI: str = "🔧"
 BORDER_LENGTH: int = 70
@@ -76,20 +78,37 @@ class SimpleLintroLogger:
         # Configure Loguru
         self._setup_loguru()
 
+    @staticmethod
+    def _get_summary_value(
+        summary: dict | object,
+        key: str,
+        default: int | float = 0,
+    ) -> int | float:
+        """Extract value from summary dict or object.
+
+        Args:
+            summary: Summary data as dict or dataclass.
+            key: Attribute/key name.
+            default: Default value if not found.
+
+        Returns:
+            int | float: The extracted value or default.
+        """
+        if isinstance(summary, dict):
+            return summary.get(key, default)
+        return getattr(summary, key, default)
+
     def _setup_loguru(self) -> None:
         """Configure Loguru with clean, simple handlers."""
         # Remove default handler
         logger.remove()
 
         # Add console handler (for immediate display)
-        console_level: str = "DEBUG" if self.verbose else "INFO"
+        # Only capture WARNING and ERROR for console
         logger.add(
             sys.stderr,
-            level=console_level,
-            format=(
-                "<green>{time:HH:mm:ss}</green> | <level>{level: <8}</level> | "
-                "{message}"
-            ),
+            level="WARNING",  # Only show warnings and errors
+            format="{message}",  # Simple format without timestamps/log levels
             colorize=True,
         )
 
@@ -115,6 +134,18 @@ class SimpleLintroLogger:
         self.console_messages.append(message)
         logger.info(message, **kwargs)
 
+    def info_blue(self, message: str, **kwargs) -> None:
+        """Log an info message to the console in blue color.
+
+        Args:
+            message: str: The message to log.
+            **kwargs: Additional keyword arguments for formatting.
+        """
+        styled_message = click.style(message, fg="cyan", bold=True)
+        click.echo(styled_message)
+        self.console_messages.append(message)
+        logger.info(message, **kwargs)
+
     def debug(self, message: str, **kwargs) -> None:
         """Log debug message.
 
@@ -270,6 +301,42 @@ class SimpleLintroLogger:
                 the result is treated as a failure even if no issues were
                 counted (e.g., parse or runtime errors).
         """
+        # Add section header for pytest/test results
+        if tool_name.lower() == "pytest":
+            self.console_output(text="")
+            self.console_output(text="🧪 Test Results")
+            self.console_output(text="-" * INFO_BORDER_LENGTH)
+
+            # Display formatted test failures table if present
+            # Skip JSON lines but keep tables
+            if output and output.strip():
+                lines = output.split("\n")
+                display_lines = []
+                skip_json = False
+                for line in lines:
+                    if line.startswith("{"):
+                        # Skip JSON summary line
+                        skip_json = True
+                        continue
+                    if skip_json and line.strip() == "":
+                        # Skip blank line after JSON
+                        skip_json = False
+                        continue
+                    if skip_json:
+                        # Skip remaining JSON content
+                        continue
+                    # Keep everything else including table headers and content
+                    display_lines.append(line)
+
+                if display_lines:
+                    self.console_output(text="\n".join(display_lines))
+
+            # Don't show summary line here - it will be in the Execution Summary table
+            if issues_count == 0 and not output:
+                self.success(message="✓ No issues found.")
+
+            return
+
         if output and output.strip():
             # Display the output (either raw or formatted, depending on what was passed)
             self.console_output(text=output)
@@ -441,6 +508,9 @@ class SimpleLintroLogger:
             action: str: The action being performed ("check" or "fmt").
             tool_results: list[object]: The list of tool results.
         """
+        # Add separation before Execution Summary
+        self.console_output(text="")
+
         # Execution summary section
         summary_header: str = click.style("📋 EXECUTION SUMMARY", fg="cyan", bold=True)
         border_line: str = click.style("=" * 50, fg="cyan")
@@ -460,6 +530,8 @@ class SimpleLintroLogger:
             for result in tool_results:
                 fixed_std = getattr(result, "fixed_issues_count", None)
                 remaining_std = getattr(result, "remaining_issues_count", None)
+                success = getattr(result, "success", True)
+
                 if fixed_std is not None:
                     total_fixed += fixed_std
                 else:
@@ -467,6 +539,10 @@ class SimpleLintroLogger:
 
                 if remaining_std is not None:
                     total_remaining += remaining_std
+                elif not success:
+                    # Tool failed - treat as having remaining issues
+                    # This covers execution errors, config errors, timeouts, etc.
+                    total_remaining += DEFAULT_REMAINING_COUNT
                 else:
                     # Fallback to parsing when standardized remaining isn't provided
                     output = getattr(result, "output", "")
@@ -481,8 +557,6 @@ class SimpleLintroLogger:
                             )
                         if remaining_match:
                             total_remaining += int(remaining_match.group(1))
-                        elif not getattr(result, "success", True):
-                            total_remaining += DEFAULT_REMAINING_COUNT
 
             # Show totals line then ASCII art
             totals_line: str = (
@@ -537,6 +611,64 @@ class SimpleLintroLogger:
                 emoji: str = get_tool_emoji(tool_name)
                 tool_display: str = f"{emoji} {tool_name}"
 
+                # Special handling for pytest/test action
+                if action == "test" and tool_name.lower() == "pytest":
+                    pytest_summary = getattr(result, "pytest_summary", None)
+                    if pytest_summary:
+                        # Use pytest summary data for more detailed display
+                        passed = int(
+                            self._get_summary_value(pytest_summary, "passed", 0),
+                        )
+                        failed = int(
+                            self._get_summary_value(pytest_summary, "failed", 0),
+                        )
+                        skipped = int(
+                            self._get_summary_value(pytest_summary, "skipped", 0),
+                        )
+                        docker_skipped = int(
+                            self._get_summary_value(
+                                pytest_summary,
+                                "docker_skipped",
+                                0,
+                            ),
+                        )
+                        duration = float(
+                            self._get_summary_value(pytest_summary, "duration", 0.0),
+                        )
+                        total = int(
+                            self._get_summary_value(pytest_summary, "total", 0),
+                        )
+
+                        # Create detailed status display
+                        status_display = (
+                            click.style("✅ PASS", fg="green", bold=True)
+                            if failed == 0
+                            else click.style("❌ FAIL", fg="red", bold=True)
+                        )
+
+                        # Format duration with proper units
+                        duration_str = f"{duration:.2f}s"
+
+                        # Format skipped count to include docker skipped info
+                        if docker_skipped > 0:
+                            skipped_display = f"{skipped} ({docker_skipped} docker)"
+                        else:
+                            skipped_display = str(skipped)
+
+                        # Create row with separate columns for each metric
+                        summary_data.append(
+                            [
+                                tool_display,
+                                status_display,
+                                str(passed),
+                                str(failed),
+                                skipped_display,
+                                str(total),
+                                duration_str,
+                            ],
+                        )
+                        continue
+
                 # For format operations, success means tool ran
                 # (regardless of fixes made)
                 # For check operations, success means no issues found
@@ -617,30 +749,73 @@ class SimpleLintroLogger:
                             bold=True,
                         )
                 else:  # check
-                    status_display = (
-                        click.style("✅ PASS", fg="green", bold=True)
-                        if (success and issues_count == 0)
-                        else click.style("❌ FAIL", fg="red", bold=True)
-                    )
-                    # Check if files were excluded
+                    # Check if this is an execution failure (timeout/error)
+                    # vs linting issues
                     result_output = getattr(result, "output", "")
-                    if result_output and any(
-                        (
-                            msg in result_output
-                            for msg in ["No files to", "No Python files found to"]
-                        ),
-                    ):
-                        issues_display: str = click.style(
+
+                    # Check if tool was skipped (version check failure, etc.)
+                    is_skipped = result_output and "skipping" in result_output.lower()
+
+                    has_execution_failure = result_output and (
+                        "timeout" in result_output.lower()
+                        or "error processing" in result_output.lower()
+                        or "tool execution failed" in result_output.lower()
+                    )
+
+                    # If tool was skipped, show SKIPPED status
+                    if is_skipped:
+                        status_display = click.style(
+                            "⏭️  SKIPPED",
+                            fg="yellow",
+                            bold=True,
+                        )
+                        issues_display = click.style(
                             "SKIPPED",
                             fg="yellow",
                             bold=True,
                         )
-                    else:
+                    # If there are execution failures but no parsed issues,
+                    # show special status
+                    elif has_execution_failure and issues_count == 0:
+                        # This shouldn't happen with our fix, but handle gracefully
+                        status_display = click.style("❌ FAIL", fg="red", bold=True)
                         issues_display = click.style(
-                            str(issues_count),
-                            fg="green" if issues_count == 0 else "red",
+                            "ERROR",
+                            fg="red",
                             bold=True,
                         )
+                    elif not success and issues_count == 0:
+                        # Execution failure with no issues parsed - show as failure
+                        status_display = click.style("❌ FAIL", fg="red", bold=True)
+                        issues_display = click.style(
+                            "ERROR",
+                            fg="red",
+                            bold=True,
+                        )
+                    else:
+                        status_display = (
+                            click.style("✅ PASS", fg="green", bold=True)
+                            if (success and issues_count == 0)
+                            else click.style("❌ FAIL", fg="red", bold=True)
+                        )
+                        # Check if files were excluded
+                        if result_output and any(
+                            (
+                                msg in result_output
+                                for msg in ["No files to", "No Python files found to"]
+                            ),
+                        ):
+                            issues_display = click.style(
+                                "SKIPPED",
+                                fg="yellow",
+                                bold=True,
+                            )
+                        else:
+                            issues_display = click.style(
+                                str(issues_count),
+                                fg="green" if issues_count == 0 else "red",
+                                bold=True,
+                            )
 
                 if action == "fmt":
                     summary_data.append(
@@ -657,7 +832,18 @@ class SimpleLintroLogger:
             # Set headers based on action
             # Use plain headers to avoid ANSI/emojis width misalignment
             headers: list[str]
-            if action == "fmt":
+            if action == "test":
+                # Special table for test action with separate columns for test metrics
+                headers = [
+                    "Tool",
+                    "Status",
+                    "Passed",
+                    "Failed",
+                    "Skipped",
+                    "Total",
+                    "Duration",
+                ]
+            elif action == "fmt":
                 headers = ["Tool", "Status", "Fixed", "Remaining"]
             else:
                 headers = ["Tool", "Status", "Issues"]

lintro/utils/path_utils.py

@@ -4,6 +4,48 @@ Small helpers to normalize paths for display consistency.
 """
 
 import os
+from pathlib import Path
+
+
+def find_lintro_ignore() -> Path | None:
+    """Find .lintro-ignore file by searching upward from current directory.
+
+    Searches upward from the current working directory to find the project root
+    by looking for .lintro-ignore or pyproject.toml files.
+
+    Returns:
+        Path | None: Path to .lintro-ignore file if found, None otherwise.
+    """
+    current_dir = Path.cwd()
+    # Limit search to prevent infinite loops (e.g., if we're in /)
+    max_depth = 20
+    depth = 0
+
+    while depth < max_depth:
+        lintro_ignore_path = current_dir / ".lintro-ignore"
+        if lintro_ignore_path.exists():
+            return lintro_ignore_path
+
+        # Also check for pyproject.toml as project root indicator
+        pyproject_path = current_dir / "pyproject.toml"
+        if pyproject_path.exists():
+            # If pyproject.toml exists, check for .lintro-ignore in same directory
+            lintro_ignore_path = current_dir / ".lintro-ignore"
+            if lintro_ignore_path.exists():
+                return lintro_ignore_path
+            # Even if .lintro-ignore doesn't exist, we found project root
+            # Return None to indicate no .lintro-ignore found
+            return None
+
+        # Move up one directory
+        parent_dir = current_dir.parent
+        if parent_dir == current_dir:
+            # Reached filesystem root
+            break
+        current_dir = parent_dir
+        depth += 1
+
+    return None
 
 
 def normalize_file_path_for_display(file_path: str) -> str: