lintro 0.3.2__py3-none-any.whl

lintro/cli.py

@@ -0,0 +1,70 @@
+"""Command-line interface for Lintro."""
+
+import click
+
+from lintro import __version__
+from lintro.cli_utils.commands.check import check_command
+from lintro.cli_utils.commands.format import format_code
+from lintro.cli_utils.commands.list_tools import list_tools_command
+
+
+class LintroGroup(click.Group):
+    def format_commands(
+        self,
+        ctx: click.Context,
+        formatter: click.HelpFormatter,
+    ) -> None:
+        """Render command list with aliases in the help output.
+
+        Args:
+            ctx: click.Context: The Click context.
+            formatter: click.HelpFormatter: The help formatter to write to.
+        """
+        # Group commands by canonical name and aliases
+        commands = self.list_commands(ctx)
+        # Map canonical name to (command, [aliases])
+        canonical_map = {}
+        for name in commands:
+            cmd = self.get_command(ctx, name)
+            if not hasattr(cmd, "_canonical_name"):
+                cmd._canonical_name = name
+            canonical = cmd._canonical_name
+            if canonical not in canonical_map:
+                canonical_map[canonical] = (cmd, [])
+            if name != canonical:
+                canonical_map[canonical][1].append(name)
+        rows = []
+        for canonical, (cmd, aliases) in canonical_map.items():
+            names = [canonical] + aliases
+            name_str = " / ".join(names)
+            rows.append((name_str, cmd.get_short_help_str()))
+        if rows:
+            with formatter.section("Commands"):
+                formatter.write_dl(rows)
+
+
+@click.group(cls=LintroGroup, invoke_without_command=True)
+@click.version_option(version=__version__)
+def cli() -> None:
+    """Lintro: Unified CLI for code formatting, linting, and quality assurance."""
+    pass
+
+
+# Register canonical commands and set _canonical_name for help
+check_command._canonical_name = "check"
+format_code._canonical_name = "format"
+list_tools_command._canonical_name = "list-tools"
+
+cli.add_command(check_command, name="check")
+cli.add_command(format_code, name="format")
+cli.add_command(list_tools_command, name="list-tools")
+
+# Register aliases
+cli.add_command(check_command, name="chk")
+cli.add_command(format_code, name="fmt")
+cli.add_command(list_tools_command, name="ls")
+
+
+def main() -> None:
+    """Entry point for the CLI."""
+    cli()

lintro/cli_utils/__init__.py

@@ -0,0 +1,7 @@
+"""CLI utilities package for lintro.
+
+This package contains command implementations and utilities for the lintro CLI.
+"""
+
+# Note: Not importing cli and main here to avoid circular imports
+# They can be imported directly from lintro.cli where needed

lintro/cli_utils/commands/__init__.py

@@ -0,0 +1,7 @@
+"""CLI command modules for lintro."""
+
+from .check import check_command
+from .format import format_code, format_code_legacy
+from .list_tools import list_tools
+
+__all__ = ["check_command", "format_code", "format_code_legacy", "list_tools"]

lintro/cli_utils/commands/check.py

@@ -0,0 +1,210 @@
+"""Check command implementation for lintro CLI.
+
+This module provides the core logic for the 'check' command.
+
+Functions:
+    check_command: CLI command for checking files with various tools.
+    check: Programmatic function for backward compatibility.
+"""
+
+import sys
+
+import click
+from click.testing import CliRunner
+
+from lintro.utils.tool_executor import run_lint_tools_simple
+
+# Constants
+DEFAULT_PATHS: list[str] = ["."]
+DEFAULT_EXIT_CODE: int = 0
+DEFAULT_ACTION: str = "check"
+
+
+@click.command("check")
+@click.argument("paths", nargs=-1, type=click.Path(exists=True))
+@click.option(
+    "--tools",
+    type=str,
+    help='Comma-separated list of tools to run. Use "all" to run all available tools.',
+)
+@click.option(
+    "--tool-options",
+    type=str,
+    help="Tool-specific options in the format tool:option=value,tool:option=value",
+)
+@click.option(
+    "--exclude",
+    type=str,
+    help="Comma-separated list of patterns to exclude from processing",
+)
+@click.option(
+    "--include-venv",
+    is_flag=True,
+    help="Include virtual environment directories in processing",
+)
+@click.option(
+    "--output",
+    type=click.Path(),
+    help="Output file path for writing results",
+)
+@click.option(
+    "--output-format",
+    type=click.Choice(["plain", "grid", "markdown", "html", "json", "csv"]),
+    default="grid",
+    help="Output format for displaying results",
+)
+@click.option(
+    "--group-by",
+    type=click.Choice(["file", "code", "none", "auto"]),
+    default="file",
+    help="How to group issues in the output",
+)
+@click.option(
+    "--ignore-conflicts",
+    is_flag=True,
+    help="Ignore potential conflicts between tools",
+)
+@click.option(
+    "--verbose",
+    is_flag=True,
+    help="Show verbose output",
+)
+@click.option(
+    "--no-log",
+    is_flag=True,
+    help="Disable logging to file",
+)
+@click.option(
+    "--raw-output",
+    is_flag=True,
+    help="Show raw tool output instead of formatted output",
+)
+def check_command(
+    paths,
+    tools,
+    tool_options,
+    exclude,
+    include_venv,
+    output,
+    output_format,
+    group_by,
+    ignore_conflicts,
+    verbose,
+    no_log,
+    raw_output,
+) -> None:
+    """Check files for issues using the specified tools.
+
+    Args:
+        paths: tuple: List of file/directory paths to check.
+        tools: str | None: Comma-separated list of tool names to run.
+        tool_options: str | None: Tool-specific configuration options.
+        exclude: str | None: Comma-separated patterns of files/dirs to exclude.
+        include_venv: bool: Whether to include virtual environment directories.
+        output: str | None: Path to output file for results.
+        output_format: str: Format for displaying results (table, json, etc).
+        group_by: str: How to group issues in output (tool, file, etc).
+        ignore_conflicts: bool: Whether to ignore tool configuration conflicts.
+        verbose: bool: Whether to show verbose output during execution.
+        no_log: bool: Whether to disable logging to file.
+        raw_output: bool: Whether to show raw tool output instead of formatted output.
+
+    Raises:
+        SystemExit: Process exit with the aggregated exit code from tools.
+    """
+    # Add default paths if none provided
+    if not paths:
+        paths = DEFAULT_PATHS
+
+    # Build tool-specific options string
+    tool_option_parts: list[str] = []
+    if tool_options:
+        tool_option_parts.append(tool_options)
+
+    # Removed darglint_timeout and prettier_timeout handling
+    combined_tool_options: str | None = (
+        ",".join(tool_option_parts) if tool_option_parts else None
+    )
+
+    # Run with simplified approach
+    exit_code: int = run_lint_tools_simple(
+        action=DEFAULT_ACTION,
+        paths=list(paths),
+        tools=tools,
+        tool_options=combined_tool_options,
+        exclude=exclude,
+        include_venv=include_venv,
+        group_by=group_by,
+        output_format=output_format,
+        verbose=verbose,
+        raw_output=raw_output,
+    )
+
+    # Exit with code only; CLI uses this as process exit code and avoids any
+    # additional trailing output after the logger's ASCII art.
+    raise SystemExit(exit_code)
+
+
+def check(
+    paths,
+    tools,
+    tool_options,
+    exclude,
+    include_venv,
+    output,
+    output_format,
+    group_by,
+    ignore_conflicts,
+    verbose,
+    no_log,
+) -> None:
+    """Programmatic check function for backward compatibility.
+
+    Args:
+        paths: tuple: List of file/directory paths to check.
+        tools: str | None: Comma-separated list of tool names to run.
+        tool_options: str | None: Tool-specific configuration options.
+        exclude: str | None: Comma-separated patterns of files/dirs to exclude.
+        include_venv: bool: Whether to include virtual environment directories.
+        output: str | None: Path to output file for results.
+        output_format: str: Format for displaying results (table, json, etc).
+        group_by: str: How to group issues in output (tool, file, etc).
+        ignore_conflicts: bool: Whether to ignore tool configuration conflicts.
+        verbose: bool: Whether to show verbose output during execution.
+        no_log: bool: Whether to disable logging to file.
+
+    Returns:
+        None: This function does not return a value.
+    """
+    # Build arguments for the click command
+    args: list[str] = []
+    if paths:
+        args.extend(paths)
+    if tools:
+        args.extend(["--tools", tools])
+    if tool_options:
+        args.extend(["--tool-options", tool_options])
+    if exclude:
+        args.extend(["--exclude", exclude])
+    if include_venv:
+        args.append("--include-venv")
+    if output:
+        args.extend(["--output", output])
+    if output_format:
+        args.extend(["--output-format", output_format])
+    if group_by:
+        args.extend(["--group-by", group_by])
+    if ignore_conflicts:
+        args.append("--ignore-conflicts")
+    # Removed darglint_timeout and prettier_timeout handling
+    if verbose:
+        args.append("--verbose")
+    if no_log:
+        args.append("--no-log")
+
+    runner = CliRunner()
+    result = runner.invoke(check_command, args)
+
+    if result.exit_code != DEFAULT_EXIT_CODE:
+        sys.exit(result.exit_code)
+    return None

lintro/cli_utils/commands/format.py

@@ -0,0 +1,167 @@
+"""Format command implementation using simplified Loguru-based approach."""
+
+import click
+from click.testing import CliRunner
+
+from lintro.utils.tool_executor import run_lint_tools_simple
+
+# Constants
+DEFAULT_PATHS: list[str] = ["."]
+DEFAULT_EXIT_CODE: int = 0
+DEFAULT_ACTION: str = "fmt"
+
+
+@click.command()
+@click.argument("paths", nargs=-1, type=click.Path(exists=True))
+@click.option(
+    "--tools",
+    default=None,
+    help="Comma-separated list of tools to run (e.g., ruff,prettier) or 'all'.",
+)
+@click.option(
+    "--tool-options",
+    default=None,
+    help="Tool-specific options in format tool:option=value,tool2:option=value.",
+)
+@click.option(
+    "--exclude",
+    default=None,
+    help="Comma-separated patterns to exclude from formatting.",
+)
+@click.option(
+    "--include-venv",
+    is_flag=True,
+    default=False,
+    help="Include virtual environment directories in formatting.",
+)
+@click.option(
+    "--group-by",
+    default="auto",
+    type=click.Choice(["file", "code", "none", "auto"]),
+    help="How to group issues in output.",
+)
+@click.option(
+    "--output-format",
+    default="grid",
+    type=click.Choice(["plain", "grid", "markdown", "html", "json", "csv"]),
+    help="Output format for displaying results.",
+)
+@click.option(
+    "--verbose",
+    "-v",
+    is_flag=True,
+    default=False,
+    help="Enable verbose output with debug information.",
+)
+@click.option(
+    "--raw-output",
+    is_flag=True,
+    default=False,
+    help="Show raw tool output instead of formatted output.",
+)
+def format_code(
+    paths: tuple[str, ...],
+    tools: str | None,
+    tool_options: str | None,
+    exclude: str | None,
+    include_venv: bool,
+    group_by: str,
+    output_format: str,
+    verbose: bool,
+    raw_output: bool,
+) -> None:
+    """Format code using configured formatting tools.
+
+    Runs code formatting tools on the specified paths to automatically fix style issues.
+    Uses simplified Loguru-based logging for clean output and proper file logging.
+
+    Args:
+        paths: tuple[str, ...]:
+            Paths to format (defaults to current directory if none provided).
+        tools: str | None: Specific tools to run, or 'all' for all available tools.
+        tool_options: str | None: Tool-specific configuration options.
+        exclude: str | None: Patterns to exclude from formatting.
+        include_venv: bool: Whether to include virtual environment directories.
+        group_by: str: How to group issues in the output display.
+        output_format: str: Format for displaying results.
+        verbose: bool: Enable detailed debug output.
+        raw_output: bool:
+            Show raw tool output instead of formatted output.
+
+    Raises:
+        ClickException: If issues are found during formatting.
+    """
+    # Default to current directory if no paths provided
+    if not paths:
+        paths = DEFAULT_PATHS
+
+    # Run with simplified approach
+    exit_code: int = run_lint_tools_simple(
+        action=DEFAULT_ACTION,
+        paths=list(paths),
+        tools=tools,
+        tool_options=tool_options,
+        exclude=exclude,
+        include_venv=include_venv,
+        group_by=group_by,
+        output_format=output_format,
+        verbose=verbose,
+        raw_output=raw_output,
+    )
+
+    # Exit with appropriate code
+    if exit_code != DEFAULT_EXIT_CODE:
+        raise click.ClickException("Format found issues")
+
+
+def format_code_legacy(
+    paths: list[str] | None = None,
+    tools: str | None = None,
+    tool_options: str | None = None,
+    exclude: str | None = None,
+    include_venv: bool = False,
+    group_by: str = "auto",
+    output_format: str = "grid",
+    verbose: bool = False,
+) -> None:
+    """Programmatic format function for backward compatibility.
+
+    Args:
+        paths: list[str] | None: List of file/directory paths to format.
+        tools: str | None: Comma-separated list of tool names to run.
+        tool_options: str | None: Tool-specific configuration options.
+        exclude: str | None: Comma-separated patterns of files/dirs to exclude.
+        include_venv: bool: Whether to include virtual environment directories.
+        group_by: str: How to group issues in output (tool, file, etc).
+        output_format: str: Format for displaying results (table, json, etc).
+        verbose: bool: Whether to show verbose output during execution.
+
+    Returns:
+        None: This function does not return a value.
+
+    Raises:
+        Exception: If format fails for any reason.
+    """
+    args: list[str] = []
+    if paths:
+        args.extend(paths)
+    if tools:
+        args.extend(["--tools", tools])
+    if tool_options:
+        args.extend(["--tool-options", tool_options])
+    if exclude:
+        args.extend(["--exclude", exclude])
+    if include_venv:
+        args.append("--include-venv")
+    if group_by:
+        args.extend(["--group-by", group_by])
+    if output_format:
+        args.extend(["--output-format", output_format])
+    if verbose:
+        args.append("--verbose")
+
+    runner = CliRunner()
+    result = runner.invoke(format_code, args)
+    if result.exit_code != DEFAULT_EXIT_CODE:
+        raise Exception(f"Format failed: {result.output}")
+    return None

lintro/cli_utils/commands/list_tools.py

@@ -0,0 +1,114 @@
+"""List tools command implementation for lintro CLI.
+
+This module provides the core logic for the 'list_tools' command.
+"""
+
+import click
+
+from lintro.enums.action import Action
+from lintro.tools import tool_manager
+from lintro.utils.console_logger import get_tool_emoji
+
+
+@click.command("list-tools")
+@click.option(
+    "--output",
+    type=click.Path(),
+    help="Output file path for writing results",
+)
+@click.option(
+    "--show-conflicts",
+    is_flag=True,
+    help="Show potential conflicts between tools",
+)
+def list_tools_command(
+    output,
+    show_conflicts,
+) -> None:
+    """List all available tools and their configurations.
+
+    Args:
+        output: Path to output file for writing results.
+        show_conflicts: Whether to show potential conflicts between tools.
+    """
+    list_tools(output=output, show_conflicts=show_conflicts)
+
+
+def list_tools(
+    output: str | None,
+    show_conflicts: bool,
+) -> None:
+    """List all available tools.
+
+    Args:
+        output: Output file path.
+        show_conflicts: Whether to show potential conflicts between tools.
+    """
+    available_tools = tool_manager.get_available_tools()
+    check_tools = tool_manager.get_check_tools()
+    fix_tools = tool_manager.get_fix_tools()
+
+    output_lines = []
+
+    # Create header with emojis
+    border = "=" * 70
+    header_title = "🔧  Available Tools"
+    emojis = "🔧 🔧 🔧 🔧 🔧"
+    output_lines.append(f"{border}")
+    output_lines.append(f"{header_title}    {emojis}")
+    output_lines.append(f"{border}")
+    output_lines.append("")
+
+    for tool_enum, tool in available_tools.items():
+        tool_name = tool_enum.name.lower()
+        tool_description = getattr(tool.config, "description", tool.__class__.__name__)
+        emoji = get_tool_emoji(tool_name)
+
+        capabilities: list[str] = []
+        if tool_enum in check_tools:
+            capabilities.append(Action.CHECK.value)
+        if tool_enum in fix_tools:
+            capabilities.append(Action.FIX.value)
+
+        output_lines.append(f"{emoji} {tool_name}: {tool_description}")
+        output_lines.append(f"  Capabilities: {', '.join(capabilities)}")
+
+        if (
+            show_conflicts
+            and hasattr(tool.config, "conflicts_with")
+            and tool.config.conflicts_with
+        ):
+            conflicts = [
+                conflict.name.lower()
+                for conflict in tool.config.conflicts_with
+                if conflict in available_tools
+            ]
+            if conflicts:
+                output_lines.append(f"  Conflicts with: {', '.join(conflicts)}")
+
+        output_lines.append("")
+
+    # Add summary footer
+    summary_border = "-" * 70
+    output_lines.append(summary_border)
+    output_lines.append(f"📊 Total tools: {len(available_tools)}")
+    output_lines.append(f"🔍 Check tools: {len(check_tools)}")
+    output_lines.append(f"🔧 Fix tools: {len(fix_tools)}")
+    output_lines.append(summary_border)
+
+    # Format output
+    output_text = "\n".join(output_lines)
+
+    # Print to console using click.echo for consistency
+    click.echo(output_text)
+
+    # Write to file if specified
+    if output:
+        try:
+            with open(output, "w", encoding="utf-8") as f:
+                f.write(output_text + "\n")
+            success_msg = f"Output written to: {output}"
+            click.echo(success_msg)
+        except IOError as e:
+            error_msg = f"Error writing to file {output}: {e}"
+            click.echo(error_msg, err=True)

lintro/enums/action.py

@@ -0,0 +1,29 @@
+"""Action/capability enum for tools (check vs. fix)."""
+
+from __future__ import annotations
+
+from enum import StrEnum
+
+
+class Action(StrEnum):
+    """Supported actions a tool can perform."""
+
+    CHECK = "check"
+    FIX = "fix"
+
+
+def normalize_action(value: str | Action) -> Action:
+    """Normalize a raw value to an Action enum.
+
+    Args:
+        value: str or Action to normalize.
+
+    Returns:
+        Action: Normalized enum value.
+    """
+    if isinstance(value, Action):
+        return value
+    try:
+        return Action(value.lower())
+    except Exception:
+        return Action.CHECK

lintro/enums/darglint_strictness.py

@@ -0,0 +1,22 @@
+"""Darglint strictness levels."""
+
+from __future__ import annotations
+
+from enum import StrEnum, auto
+
+
+class DarglintStrictness(StrEnum):
+    SHORT = auto()
+    LONG = auto()
+    FULL = auto()
+
+
+def normalize_darglint_strictness(
+    value: str | DarglintStrictness,
+) -> DarglintStrictness:
+    if isinstance(value, DarglintStrictness):
+        return value
+    try:
+        return DarglintStrictness[value.upper()]
+    except Exception:
+        return DarglintStrictness.FULL

lintro/enums/group_by.py

@@ -0,0 +1,31 @@
+"""Grouping strategy enum definitions."""
+
+from __future__ import annotations
+
+from enum import StrEnum, auto
+
+
+class GroupBy(StrEnum):
+    """Supported grouping strategies for presenting issues."""
+
+    FILE = auto()
+    CODE = auto()
+    NONE = auto()
+    AUTO = auto()
+
+
+def normalize_group_by(value: str | GroupBy) -> GroupBy:
+    """Normalize a raw value to GroupBy enum.
+
+    Args:
+        value: str or GroupBy to normalize.
+
+    Returns:
+        GroupBy: Normalized enum value.
+    """
+    if isinstance(value, GroupBy):
+        return value
+    try:
+        return GroupBy[value.upper()]
+    except Exception:
+        return GroupBy.FILE