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

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,10 +115,11 @@ 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):
-                with open(lintro_ignore_path, "r", encoding="utf-8") as f:
+            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()
                         if not line_stripped or line_stripped.startswith("#"):
@@ -147,6 +164,9 @@ class BaseTool(ABC):
             TimeoutExpired: If command times out.
             FileNotFoundError: If command executable is not found.
         """
+        # Validate command arguments for safety prior to execution
+        self._validate_subprocess_command(cmd=cmd)
+
         try:
             result = subprocess.run(  # nosec B603 - args list, shell=False
                 cmd,
@@ -157,7 +177,6 @@ class BaseTool(ABC):
                     "timeout",
                     self._default_timeout,
                 ),
-                check=False,
                 cwd=cwd,
             )
             return result.returncode == 0, result.stdout + result.stderr
@@ -184,6 +203,31 @@ class BaseTool(ABC):
                 f"Please ensure it is installed and in your PATH.",
             ) from e
 
+    def _validate_subprocess_command(self, cmd: list[str]) -> None:
+        """Validate a subprocess command argument list for safety.
+
+        Ensures that the command is a non-empty list of strings and that no
+        argument contains shell metacharacters that could enable command
+        injection when passed to subprocess (even with ``shell=False``).
+
+        Args:
+            cmd: list[str]: Command and arguments to validate.
+
+        Raises:
+            ValueError: If the command list is empty, contains non-strings,
+                or contains unsafe characters.
+        """
+        if not cmd or not isinstance(cmd, list):
+            raise ValueError("Command must be a non-empty list of strings")
+
+        unsafe_chars: set[str] = {";", "&", "|", ">", "<", "`", "$", "\\", "\n", "\r"}
+
+        for arg in cmd:
+            if not isinstance(arg, str):
+                raise ValueError("All command arguments must be strings")
+            if any(ch in arg for ch in unsafe_chars):
+                raise ValueError("Unsafe character detected in command argument")
+
     def set_options(self, **kwargs) -> None:
         """Set core options.
 
@@ -233,11 +277,10 @@ class BaseTool(ABC):
         self,
         paths: list[str],
     ) -> str | None:
-        """Return the common parent directory for the given paths, or None if not
-        applicable.
+        """Return the common parent directory for the given paths.
 
         Args:
-            paths: list[str]: List of file paths to find common parent directory for.
+            paths: list[str]: Paths to compute a common parent directory for.
 
         Returns:
             str | None: Common parent directory path, or None if not applicable.
@@ -256,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("uv"):
-                return ["uv", "run", tool_name]
-            if shutil.which("uvx"):
-                return ["uvx", 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