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

lintro/tools/core/timeout_utils.py

@@ -0,0 +1,112 @@
+"""Shared timeout handling utilities for tool implementations.
+
+This module provides standardized timeout handling across different tools,
+ensuring consistent behavior and error messages for subprocess timeouts.
+"""
+
+import subprocess  # nosec B404 - used safely with shell disabled
+from typing import Any
+
+from loguru import logger
+
+
+def run_subprocess_with_timeout(
+    tool,
+    cmd: list[str],
+    timeout: int | None = None,
+    cwd: str | None = None,
+    tool_name: str | None = None,
+) -> tuple[bool, str]:
+    """Run a subprocess command with timeout handling.
+
+    This is a wrapper around tool._run_subprocess that provides consistent
+    timeout error handling and messaging across different tools.
+
+    Args:
+        tool: Tool instance with _run_subprocess method.
+        cmd: Command to run.
+        timeout: Timeout in seconds. If None, uses tool's default timeout.
+        cwd: Working directory for command execution.
+        tool_name: Name of the tool for error messages. If None, uses tool.name.
+
+    Returns:
+        tuple[bool, str]: (success, output) where success is True if command
+        succeeded without timeout, and output contains command output or
+        timeout error message.
+
+    Raises:
+        TimeoutExpired: If command times out (re-raised from subprocess).
+    """
+    tool_name = tool_name or tool.name
+
+    try:
+        return tool._run_subprocess(cmd=cmd, timeout=timeout, cwd=cwd)
+    except subprocess.TimeoutExpired as e:
+        # Re-raise with more context for the calling tool
+        actual_timeout = timeout or tool.options.get("timeout", tool._default_timeout)
+        timeout_msg = (
+            f"{tool_name} execution timed out ({actual_timeout}s limit exceeded).\n\n"
+            "This may indicate:\n"
+            "  - Large codebase taking too long to process\n"
+            "  - Need to increase timeout via --tool-options timeout=N\n"
+            "  - Command hanging due to external dependencies\n"
+        )
+        logger.warning(timeout_msg)
+
+        # Create a new TimeoutExpired with enhanced message
+        raise subprocess.TimeoutExpired(
+            cmd=cmd,
+            timeout=actual_timeout,
+            output=timeout_msg,
+        ) from e
+
+
+def get_timeout_value(tool, default_timeout: int | None = None) -> int:
+    """Get timeout value from tool options with fallback to default.
+
+    Args:
+        tool: Tool instance with options.
+        default_timeout: Default timeout if not specified in options.
+
+    Returns:
+        int: Timeout value in seconds.
+    """
+    if default_timeout is None:
+        default_timeout = getattr(tool, "_default_timeout", 300)
+
+    return tool.options.get("timeout", default_timeout)
+
+
+def create_timeout_result(
+    tool,
+    timeout: int,
+    cmd: list[str] | None = None,
+    tool_name: str | None = None,
+) -> dict[str, Any]:
+    """Create a standardized timeout result dictionary.
+
+    Args:
+        tool: Tool instance.
+        timeout: Timeout value that was exceeded.
+        cmd: Optional command that timed out.
+        tool_name: Optional tool name override.
+
+    Returns:
+        dict: Result dictionary with timeout information.
+    """
+    tool_name = tool_name or tool.name
+
+    return {
+        "success": False,
+        "output": (
+            f"{tool_name} execution timed out ({timeout}s limit exceeded).\n\n"
+            "This may indicate:\n"
+            "  - Large codebase taking too long to process\n"
+            "  - Need to increase timeout via --tool-options timeout=N\n"
+            "  - Command hanging due to external dependencies\n"
+        ),
+        "issues_count": 1,  # Count timeout as execution failure
+        "issues": [],
+        "timed_out": True,
+        "timeout_seconds": timeout,
+    }

lintro/tools/core/tool_base.py

@@ -1,15 +1,20 @@
 """Base core implementation for Lintro."""
 
+from __future__ import annotations
+
 import os
 import shutil
 import subprocess  # nosec B404 - subprocess used safely with shell=False
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
+from pathlib import Path
 
 from loguru import logger
 
+from lintro.config import LintroConfig
 from lintro.enums.tool_type import ToolType
 from lintro.models.core.tool import ToolConfig, ToolResult
+from lintro.utils.path_utils import find_lintro_ignore
 
 # Constants for default values
 DEFAULT_TIMEOUT: int = 30
@@ -91,6 +96,17 @@ class BaseTool(ABC):
         if not isinstance(self.config.tool_type, ToolType):
             raise ValueError("Tool tool_type must be a ToolType instance")
 
+    def _find_lintro_ignore(self) -> str | None:
+        """Find .lintro-ignore file by searching upward from current directory.
+
+        Uses the shared utility function to ensure consistent behavior.
+
+        Returns:
+            str | None: Path to .lintro-ignore file if found, None otherwise.
+        """
+        lintro_ignore_path = find_lintro_ignore()
+        return str(lintro_ignore_path) if lintro_ignore_path else None
+
     def _setup_defaults(self) -> None:
         """Set up default core options and patterns."""
         # Add default exclude patterns if not already present
@@ -99,9 +115,10 @@ class BaseTool(ABC):
                 self.exclude_patterns.append(pattern)
 
         # Add .lintro-ignore patterns (project-wide) if present
+        # Search upward from current directory to find project root
         try:
-            lintro_ignore_path = os.path.abspath(".lintro-ignore")
-            if os.path.exists(lintro_ignore_path):
+            lintro_ignore_path = self._find_lintro_ignore()
+            if lintro_ignore_path and os.path.exists(lintro_ignore_path):
                 with open(lintro_ignore_path, encoding="utf-8") as f:
                     for line in f:
                         line_stripped = line.strip()
@@ -282,64 +299,257 @@ class BaseTool(ABC):
     ) -> list[str]:
         """Get the command prefix to execute a tool.
 
-        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.
+        Uses a unified approach based on tool category:
+        - Python bundled tools: Use python -m (guaranteed to use lintro's environment)
+        - Node.js tools: Use npx (respects project's package.json)
+        - Binary tools: Use system executable
 
         Args:
             tool_name: str: Name of the tool executable to find.
 
         Returns:
             list[str]: Command prefix to execute the tool.
-
-        Examples:
-            >>> self._get_executable_command("ruff")
-            ["uv", "run", "ruff"]  # preferred when uv is available
-
-            >>> self._get_executable_command("ruff")
-            ["ruff"]  # if uv is not available but the tool is on PATH
         """
-        # 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]
+        import sys
+
+        # Python tools bundled with lintro (guaranteed in our environment)
+        # Note: darglint cannot be run as a module (python -m darglint),
+        # so it's excluded
+        python_bundled_tools = {"ruff", "black", "bandit", "yamllint"}
+        if tool_name in python_bundled_tools:
+            # Use python -m to ensure we use the tool from lintro's environment
+            python_exe = sys.executable
+            if python_exe:
+                return [python_exe, "-m", tool_name]
+            # Fallback to direct executable if python path not found
             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]
+        # Pytest: user environment tool (not bundled)
+        if tool_name == "pytest":
+            # Use python -m pytest for cross-platform compatibility
+            python_exe = sys.executable
+            if python_exe:
+                return [python_exe, "-m", "pytest"]
+            # Fall back to direct executable
             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("uvx"):
-                return ["uvx", tool_name]
-            if shutil.which("uv"):
-                return ["uv", "run", tool_name]
+        # Node.js tools: use npx to respect project's package.json
+        nodejs_tools = {"eslint", "prettier"}
+        if tool_name in nodejs_tools:
+            if shutil.which("npx"):
+                return ["npx", "--yes", tool_name]
+            # Fall back to direct executable
             return [tool_name]
 
-        # 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]
+        # Binary tools: use system executable
         return [tool_name]
 
+    def _verify_tool_version(self) -> ToolResult | None:
+        """Verify that the tool meets minimum version requirements.
+
+        Returns:
+            Optional[ToolResult]: None if version check passes, or a skip result
+                if it fails
+        """
+        from lintro.tools.core.version_requirements import check_tool_version
+
+        command = self._get_executable_command(self.name)
+        version_info = check_tool_version(self.name, command)
+
+        if version_info.version_check_passed:
+            return None  # Version check passed
+
+        # Version check failed - return skip result with warning
+        skip_message = (
+            f"Skipping {self.name}: {version_info.error_message}. "
+            f"Minimum required: {version_info.min_version}. "
+            f"{version_info.install_hint}"
+        )
+
+        return ToolResult(
+            name=self.name,
+            success=True,  # Not an error, just skipping
+            output=skip_message,
+            issues_count=0,
+        )
+
+    # -------------------------------------------------------------------------
+    # Lintro Config Support - Tiered Model
+    # -------------------------------------------------------------------------
+
+    def _get_lintro_config(self) -> LintroConfig:
+        """Get the current Lintro configuration.
+
+        Returns:
+            LintroConfig: The loaded Lintro configuration.
+        """
+        from lintro.config import get_config
+
+        return get_config()
+
+    def _should_use_lintro_config(self) -> bool:
+        """Check if Lintro config should be used.
+
+        Returns True if:
+        1. LINTRO_SKIP_CONFIG_INJECTION env var is NOT set, AND
+        2. A .lintro-config.yaml exists, OR [tool.lintro] is in pyproject.toml
+
+        Returns:
+            bool: True if Lintro config should be used.
+        """
+        # Allow tests to disable config injection
+        if os.environ.get("LINTRO_SKIP_CONFIG_INJECTION"):
+            return False
+
+        lintro_config = self._get_lintro_config()
+        return lintro_config.config_path is not None
+
+    def _get_enforced_settings(self) -> set[str]:
+        """Get the set of settings that are enforced by Lintro config.
+
+        This allows tools to check whether a setting is already being
+        injected via CLI args from the enforce tier, so they can avoid
+        adding duplicate arguments from their own options.
+
+        Returns:
+            set[str]: Set of setting names like 'line_length', 'target_python'.
+        """
+        if not self._should_use_lintro_config():
+            return set()
+
+        lintro_config = self._get_lintro_config()
+        enforced: set[str] = set()
+
+        if lintro_config.enforce.line_length is not None:
+            enforced.add("line_length")
+        if lintro_config.enforce.target_python is not None:
+            enforced.add("target_python")
+
+        return enforced
+
+    def _get_enforce_cli_args(self) -> list[str]:
+        """Get CLI arguments for enforced settings.
+
+        Returns CLI args that inject enforce settings (like line_length)
+        directly into the tool command line.
+
+        Returns:
+            list[str]: CLI arguments for enforced settings.
+        """
+        from lintro.config import get_enforce_cli_args
+
+        if not self._should_use_lintro_config():
+            return []
+
+        lintro_config = self._get_lintro_config()
+        return get_enforce_cli_args(
+            tool_name=self.name,
+            lintro_config=lintro_config,
+        )
+
+    def _get_defaults_config_args(self) -> list[str]:
+        """Get CLI arguments for defaults config injection.
+
+        If the tool has no native config and defaults are defined in
+        the Lintro config, generates a temp config file and returns
+        the CLI args to pass it to the tool.
+
+        Returns:
+            list[str]: CLI arguments for defaults config injection.
+        """
+        from lintro.config import (
+            generate_defaults_config,
+            get_defaults_injection_args,
+        )
+
+        if not self._should_use_lintro_config():
+            return []
+
+        lintro_config = self._get_lintro_config()
+        config_path = generate_defaults_config(
+            tool_name=self.name,
+            lintro_config=lintro_config,
+        )
+
+        if config_path is None:
+            return []
+
+        return get_defaults_injection_args(
+            tool_name=self.name,
+            config_path=config_path,
+        )
+
+    def _build_config_args(self) -> list[str]:
+        """Build complete config-related CLI arguments for this tool.
+
+        Uses the tiered model:
+        1. Enforced settings are injected via CLI flags
+        2. Defaults config is used only if no native config exists
+
+        Returns:
+            list[str]: Combined CLI arguments for configuration.
+        """
+        args: list[str] = []
+
+        # Add enforce CLI args (e.g., --line-length 88)
+        args.extend(self._get_enforce_cli_args())
+
+        # Add defaults config args if applicable
+        args.extend(self._get_defaults_config_args())
+
+        return args
+
+    # -------------------------------------------------------------------------
+    # Deprecated methods for backward compatibility
+    # -------------------------------------------------------------------------
+
+    def _generate_tool_config(self) -> Path | None:
+        """Generate a temporary config file for this tool.
+
+        DEPRECATED: Use _get_enforce_cli_args() and _get_defaults_config_args()
+        instead.
+
+        Returns:
+            Path | None: Path to generated config file, or None if not needed.
+        """
+        from lintro.config import generate_defaults_config
+
+        logger.debug(
+            f"_generate_tool_config() is deprecated for {self.name}. "
+            "Use _build_config_args() or call _get_enforce_cli_args() and "
+            "_get_defaults_config_args() directly.",
+        )
+        lintro_config = self._get_lintro_config()
+        return generate_defaults_config(
+            tool_name=self.name,
+            lintro_config=lintro_config,
+        )
+
+    def _get_config_injection_args(self) -> list[str]:
+        """Get CLI arguments to inject Lintro config into this tool.
+
+        DEPRECATED: Use _get_enforce_cli_args() and _get_defaults_config_args()
+        instead, or use _build_config_args() which combines both.
+
+        Returns:
+            list[str]: CLI arguments for config injection (enforce + defaults).
+        """
+        args: list[str] = []
+        args.extend(self._get_enforce_cli_args())
+        args.extend(self._get_defaults_config_args())
+        return args
+
+    def _get_no_auto_config_args(self) -> list[str]:
+        """Get CLI arguments to disable native config auto-discovery.
+
+        DEPRECATED: No longer needed with the tiered model.
+        Tools use their native configs by default.
+
+        Returns:
+            list[str]: Empty list (no longer used).
+        """
+        return []
+
     @abstractmethod
     def check(
         self,

lintro/tools/core/tool_manager.py

@@ -3,8 +3,11 @@
 from dataclasses import dataclass, field
 from typing import Any
 
+from loguru import logger
+
 from lintro.models.core.tool import Tool
 from lintro.tools.tool_enum import ToolEnum
+from lintro.utils.unified_config import get_ordered_tools
 
 
 @dataclass
@@ -14,9 +17,14 @@ class ToolManager:
     This class is responsible for:
     - Tool registration
     - Tool conflict resolution
-    - Tool execution order
+    - Tool execution order (priority-based, alphabetical, or custom)
     - Tool configuration management
 
+    Tool ordering is controlled by [tool.lintro].tool_order in pyproject.toml:
+    - "priority" (default): Formatters run before linters based on priority values
+    - "alphabetical": Tools run in alphabetical order by name
+    - "custom": Tools run in order specified by [tool.lintro].tool_order_custom
+
     Attributes:
         _tools: Dictionary mapping core names to core classes
         _check_tools: Dictionary mapping core names to core classes that can check
@@ -77,17 +85,23 @@ class ToolManager:
     ) -> list[ToolEnum]:
         """Get the order in which tools should be executed.
 
-        This method takes into account:
-        - Tool conflicts
-        - Alphabetical ordering
-        - Tool dependencies
+        Tool ordering is controlled by [tool.lintro].tool_order in pyproject.toml:
+        - "priority" (default): Formatters run before linters based on priority
+        - "alphabetical": Tools run in alphabetical order by name
+        - "custom": Tools run in order specified by [tool.lintro].tool_order_custom
+
+        This method also handles:
+        - Tool conflicts (unless ignore_conflicts is True)
 
         Args:
-            tool_list: List of core names to execute
-            ignore_conflicts: Whether to ignore core conflicts
+            tool_list: List of tools to order.
+            ignore_conflicts: If True, skip conflict checking.
 
         Returns:
-            List of core names in alphabetical execution order
+            List of ToolEnum members in execution order based on configured strategy.
+
+        Raises:
+            ValueError: If duplicate tools are found in tool_list.
         """
         if not tool_list:
             return []
@@ -95,30 +109,69 @@ class ToolManager:
         # Get core instances
         tools = {name: self.get_tool(name) for name in tool_list}
 
-        # Sort tools alphabetically by name
-        if ignore_conflicts:
-            return sorted(
-                tool_list,
-                key=lambda name: name.name,
+        # Validate for duplicate tools
+        seen_names: set[str] = set()
+        duplicates: list[str] = []
+        for tool in tool_list:
+            tool_name_lower = tool.name.lower()
+            if tool_name_lower in seen_names:
+                duplicates.append(tool.name)
+            else:
+                seen_names.add(tool_name_lower)
+        if duplicates:
+            raise ValueError(
+                f"Duplicate tools found in tool_list: {', '.join(duplicates)}",
             )
 
+        # Convert ToolEnum to tool names for unified config ordering
+        tool_names = [t.name.lower() for t in tool_list]
+        ordered_names = get_ordered_tools(tool_names)
+
+        # Map back to ToolEnum in the ordered sequence
+        name_to_enum = {t.name.lower(): t for t in tool_list}
+        sorted_tools = [
+            name_to_enum[name] for name in ordered_names if name in name_to_enum
+        ]
+
+        # Validate that all requested tools are preserved
+        original_names = {t.name.lower() for t in tool_list}
+        sorted_names = {t.name.lower() for t in sorted_tools}
+        missing_tools = original_names - sorted_names
+        if missing_tools:
+            # Append missing tools in their original order
+            missing_enums = [t for t in tool_list if t.name.lower() in missing_tools]
+            sorted_tools.extend(missing_enums)
+            logger.warning(
+                f"Some tools were not found in ordered list and appended: "
+                f"{[t.name for t in missing_enums]}",
+            )
+
+        if ignore_conflicts:
+            return sorted_tools
+
         # Build conflict graph
         conflict_graph: dict[ToolEnum, set[ToolEnum]] = {
             name: set() for name in tool_list
         }
+        # Create mapping from tool name strings to ToolEnum members
+        # Handle both lowercase strings and ToolEnum members in conflicts_with
+        name_to_enum_map = {t.name.lower(): t for t in ToolEnum}
         for name, tool in tools.items():
             for conflict in tool.config.conflicts_with:
-                if conflict in tool_list:
-                    conflict_graph[name].add(conflict)
-                    conflict_graph[conflict].add(name)
-
-        # Sort tools alphabetically by name
-        sorted_tools = sorted(
-            tool_list,
-            key=lambda name: name.name,
-        )
-
-        # Resolve conflicts by keeping the first alphabetical tool
+                # Convert conflict string to ToolEnum if needed
+                conflict_enum: ToolEnum | None = None
+                if isinstance(conflict, str):
+                    # Look up by lowercase name
+                    conflict_enum = name_to_enum_map.get(conflict.lower())
+                elif isinstance(conflict, ToolEnum):
+                    # Already a ToolEnum member
+                    conflict_enum = conflict
+                # Only add to conflict graph if conflict_enum is in tool_list
+                if conflict_enum is not None and conflict_enum in tool_list:
+                    conflict_graph[name].add(conflict_enum)
+                    conflict_graph[conflict_enum].add(name)
+
+        # Resolve conflicts by keeping the first tool in ordered sequence
         result = []
         for tool_name in sorted_tools:
             # Check if this core conflicts with any already selected tools