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

lintro/__init__.py

@@ -1,3 +1,3 @@
 """Lintro - A unified CLI core for code formatting, linting, and quality assurance."""
 
-__version__ = "0.6.2"
+__version__ = "0.17.2"

lintro/cli.py

@@ -1,31 +1,70 @@
 """Command-line interface for Lintro."""
 
 import click
+from loguru import logger
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
 
 from lintro import __version__
 from lintro.cli_utils.commands.check import check_command
+from lintro.cli_utils.commands.config import config_command
 from lintro.cli_utils.commands.format import format_code
+from lintro.cli_utils.commands.init import init_command
 from lintro.cli_utils.commands.list_tools import list_tools_command
+from lintro.cli_utils.commands.test import test_command
+from lintro.cli_utils.commands.versions import versions_command
 
 
 class LintroGroup(click.Group):
-    def format_commands(
+    """Custom Click group with enhanced help rendering and command chaining.
+
+    This group prints command aliases alongside their canonical names to make
+    the CLI help output more discoverable. It also supports command chaining
+    with comma-separated commands (e.g., lintro fmt , chk , tst).
+    """
+
+    def format_help(
         self,
         ctx: click.Context,
         formatter: click.HelpFormatter,
     ) -> None:
-        """Render command list with aliases in the help output.
+        """Render help with Rich formatting.
 
         Args:
             ctx: click.Context: The Click context.
-            formatter: click.HelpFormatter: The help formatter to write to.
+            formatter: click.HelpFormatter: The help formatter (unused, we use Rich).
         """
-        # Group commands by canonical name and aliases
+        console = Console()
+
+        # Header panel
+        header = Text()
+        header.append("🔧 Lintro", style="bold cyan")
+        header.append(f" v{__version__}", style="dim")
+        console.print(Panel(header, border_style="cyan"))
+        console.print()
+
+        # Description
+        console.print(
+            "[white]Unified CLI for code formatting, linting, "
+            "and quality assurance.[/white]",
+        )
+        console.print()
+
+        # Usage
+        console.print("[bold cyan]Usage:[/bold cyan]")
+        console.print("  lintro [OPTIONS] COMMAND [ARGS]...")
+        console.print("  lintro COMMAND1 , COMMAND2 , ...  [dim](chain commands)[/dim]")
+        console.print()
+
+        # Commands table
         commands = self.list_commands(ctx)
-        # Map canonical name to (command, [aliases])
-        canonical_map = {}
+        canonical_map: dict[str, tuple[click.Command, list[str]]] = {}
         for name in commands:
             cmd = self.get_command(ctx, name)
+            if cmd is None:
+                continue
             if not hasattr(cmd, "_canonical_name"):
                 cmd._canonical_name = name
             canonical = cmd._canonical_name
@@ -33,14 +72,180 @@ class LintroGroup(click.Group):
                 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)
+
+        table = Table(title="Commands", show_header=True, header_style="bold cyan")
+        table.add_column("Command", style="cyan", no_wrap=True)
+        table.add_column("Alias", style="yellow", no_wrap=True)
+        table.add_column("Description", style="white")
+
+        for canonical, (cmd, aliases) in sorted(canonical_map.items()):
+            alias_str = ", ".join(aliases) if aliases else "-"
+            table.add_row(canonical, alias_str, cmd.get_short_help_str())
+
+        console.print(table)
+        console.print()
+
+        # Options
+        console.print("[bold cyan]Options:[/bold cyan]")
+        console.print("  [yellow]--version[/yellow]  Show the version and exit.")
+        console.print("  [yellow]--help[/yellow]     Show this message and exit.")
+        console.print()
+
+        # Examples
+        console.print("[bold cyan]Examples:[/bold cyan]")
+        console.print("  [dim]# Check all files[/dim]")
+        console.print("  lintro check .")
+        console.print()
+        console.print("  [dim]# Format and then check[/dim]")
+        console.print("  lintro fmt . , chk .")
+        console.print()
+        console.print("  [dim]# Show tool versions[/dim]")
+        console.print("  lintro versions")
+
+    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.
+        """
+        # This is now handled by format_help, but keep for compatibility
+        pass
+
+    def invoke(
+        self,
+        ctx: click.Context,
+    ) -> int:
+        """Handle command execution with support for command chaining.
+
+        Supports chaining commands with commas, e.g.: lintro fmt , chk , tst
+
+        Args:
+            ctx: click.Context: The Click context.
+
+        Returns:
+            int: Exit code from command execution.
+
+        Raises:
+            KeyboardInterrupt: If the user interrupts command execution.
+            SystemExit: If a command exits with a non-zero exit code.
+        """
+        all_args = ctx.protected_args + ctx.args
+        if all_args:
+            # Get set of known command names/aliases
+            command_names = set(self.list_commands(ctx))
+            normalized_args: list[str] = []
+            saw_separator = False
+
+            for arg in all_args:
+                if arg == ",":
+                    normalized_args.append(arg)
+                    saw_separator = True
+                    continue
+
+                if "," in arg:
+                    # Check if this looks like comma-separated commands
+                    raw_parts = [part.strip() for part in arg.split(",")]
+                    # Filter out empty fragments after splitting
+                    fragments = [part for part in raw_parts if part]
+                    # Only split if all parts are known commands
+                    if fragments and all(part in command_names for part in fragments):
+                        # Split into separate tokens
+                        for idx, part in enumerate(fragments):
+                            if part:
+                                normalized_args.append(part)
+                            if idx < len(fragments) - 1:
+                                normalized_args.append(",")
+                                saw_separator = True
+                        continue
+                    # Not all parts are commands, keep as-is (e.g., --tools ruff,bandit)
+                    normalized_args.append(arg)
+                    continue
+
+                normalized_args.append(arg)
+
+            if saw_separator:
+                # Parse chained commands from normalized args
+                command_groups: list[list[str]] = []
+                current_group: list[str] = []
+
+                for arg in normalized_args:
+                    if arg == ",":
+                        if current_group:
+                            command_groups.append(current_group)
+                            current_group = []
+                        continue
+                    current_group.append(arg)
+
+                if current_group:
+                    command_groups.append(current_group)
+
+                # Execute each command group
+                exit_codes: list[int] = []
+                for cmd_args in command_groups:
+                    if not cmd_args:
+                        continue
+                    # Create a new context for each command
+                    ctx_copy = self.make_context(
+                        ctx.info_name,
+                        cmd_args,
+                        parent=ctx,
+                        allow_extra_args=True,
+                        allow_interspersed_args=False,
+                    )
+                    # Invoke the command
+                    with ctx_copy.scope() as subctx:
+                        try:
+                            result = super().invoke(subctx)
+                            exit_codes.append(result if isinstance(result, int) else 0)
+                        except SystemExit as e:
+                            exit_codes.append(
+                                (
+                                    e.code
+                                    if isinstance(e.code, int)
+                                    else (0 if e.code is None else 1)
+                                ),
+                            )
+                        except KeyboardInterrupt:
+                            # Re-raise KeyboardInterrupt to allow normal interruption
+                            raise
+                        except Exception as e:
+                            # Catch all other exceptions to allow command chain to
+                            # continue
+                            exit_code = getattr(e, "exit_code", 1)
+                            exit_codes.append(exit_code)
+                            # Log the exception with full traceback
+                            logger.exception(
+                                (
+                                    f"Error executing command "
+                                    f"'{' '.join(cmd_args)}': {type(e).__name__}: {e}"
+                                ),
+                            )
+                            # Also echo to stderr for immediate user feedback
+                            click.echo(
+                                click.style(
+                                    (
+                                        f"Error executing command "
+                                        f"'{' '.join(cmd_args)}': "
+                                        f"{type(e).__name__}: {e}"
+                                    ),
+                                    fg="red",
+                                ),
+                                err=True,
+                            )
+
+                # Return aggregated exit code (0 only if all succeeded)
+                final_exit_code = max(exit_codes) if exit_codes else 0
+                if final_exit_code != 0:
+                    raise SystemExit(final_exit_code)
+                return 0
+
+        # Normal single command execution
+        return super().invoke(ctx)
 
 
 @click.group(cls=LintroGroup, invoke_without_command=True)
@@ -52,17 +257,28 @@ def cli() -> None:
 
 # Register canonical commands and set _canonical_name for help
 check_command._canonical_name = "check"
+config_command._canonical_name = "config"
 format_code._canonical_name = "format"
+init_command._canonical_name = "init"
+test_command._canonical_name = "test"
 list_tools_command._canonical_name = "list-tools"
+versions_command._canonical_name = "versions"
 
 cli.add_command(check_command, name="check")
+cli.add_command(config_command, name="config")
 cli.add_command(format_code, name="format")
+cli.add_command(init_command, name="init")
+cli.add_command(test_command, name="test")
 cli.add_command(list_tools_command, name="list-tools")
+cli.add_command(versions_command, name="versions")
 
 # Register aliases
 cli.add_command(check_command, name="chk")
+cli.add_command(config_command, name="cfg")
 cli.add_command(format_code, name="fmt")
+cli.add_command(test_command, name="tst")
 cli.add_command(list_tools_command, name="ls")
+cli.add_command(versions_command, name="ver")
 
 
 def main() -> None:

lintro/cli_utils/commands/__init__.py

@@ -2,6 +2,13 @@
 
 from .check import check_command
 from .format import format_code, format_code_legacy
+from .init import init_command
 from .list_tools import list_tools
 
-__all__ = ["check_command", "format_code", "format_code_legacy", "list_tools"]
+__all__ = [
+    "check_command",
+    "format_code",
+    "format_code_legacy",
+    "init_command",
+    "list_tools",
+]

lintro/cli_utils/commands/check.py

@@ -138,6 +138,7 @@ def check_command(
         output_format=output_format,
         verbose=verbose,
         raw_output=raw_output,
+        output_file=output,
     )
 
     # Exit with code only; CLI uses this as process exit code and avoids any

lintro/cli_utils/commands/config.py

@@ -0,0 +1,325 @@
+"""Config command for displaying Lintro configuration status."""
+
+from typing import Any
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from lintro.config import LintroConfig, get_config
+from lintro.utils.unified_config import (
+    _load_native_tool_config,
+    get_ordered_tools,
+    get_tool_priority,
+    is_tool_injectable,
+    validate_config_consistency,
+)
+
+
+def _get_all_tool_names() -> list[str]:
+    """Get list of all known tool names.
+
+    Returns:
+        list[str]: Sorted list of tool names.
+    """
+    return [
+        "ruff",
+        "black",
+        "prettier",
+        "eslint",
+        "yamllint",
+        "markdownlint",
+        "darglint",
+        "bandit",
+        "hadolint",
+        "actionlint",
+        "pytest",
+    ]
+
+
+@click.command()
+@click.option(
+    "--verbose",
+    "-v",
+    is_flag=True,
+    help="Show detailed configuration including native tool configs.",
+)
+@click.option(
+    "--json",
+    "json_output",
+    is_flag=True,
+    help="Output configuration as JSON.",
+)
+def config_command(
+    verbose: bool,
+    json_output: bool,
+) -> None:
+    """Display Lintro configuration status.
+
+    Shows the unified configuration for all tools including:
+    - Config source (.lintro-config.yaml or pyproject.toml)
+    - Global settings (line_length, tool ordering strategy)
+    - Tool execution order based on configured strategy
+    - Per-tool effective configuration
+    - Configuration warnings and inconsistencies
+
+    Args:
+        verbose: Show detailed configuration including native tool configs.
+        json_output: Output configuration as JSON.
+    """
+    console = Console()
+    config = get_config(reload=True)
+
+    if json_output:
+        _output_json(config=config, verbose=verbose)
+        return
+
+    _output_rich(
+        console=console,
+        config=config,
+        verbose=verbose,
+    )
+
+
+def _output_json(
+    config: LintroConfig,
+    verbose: bool = False,
+) -> None:
+    """Output configuration as JSON.
+
+    Args:
+        config: LintroConfig instance from get_config()
+        verbose: Include native configs in output when True
+    """
+    import json
+
+    # Get tool order settings
+    tool_order = config.execution.tool_order
+    if isinstance(tool_order, list):
+        order_strategy = "custom"
+        custom_order = tool_order
+    else:
+        order_strategy = tool_order or "priority"
+        custom_order = []
+
+    # Get list of all known tools
+    tool_names = _get_all_tool_names()
+    ordered_tools = get_ordered_tools(
+        tool_names=tool_names,
+        tool_order=config.execution.tool_order,
+    )
+
+    output = {
+        "config_source": config.config_path or "defaults",
+        "global_settings": {
+            "line_length": config.enforce.line_length,
+            "target_python": config.enforce.target_python,
+            "tool_order": order_strategy,
+            "custom_order": custom_order,
+        },
+        "execution": {
+            "enabled_tools": config.execution.enabled_tools or "all",
+            "fail_fast": config.execution.fail_fast,
+            "parallel": config.execution.parallel,
+        },
+        "tool_execution_order": [
+            {"tool": t, "priority": get_tool_priority(t)} for t in ordered_tools
+        ],
+        "tool_configs": {},
+        "warnings": validate_config_consistency(),
+    }
+
+    for tool_name in tool_names:
+        tool_config = config.get_tool_config(tool_name)
+        effective_ll = config.get_effective_line_length(tool_name)
+
+        tool_output: dict[str, Any] = {
+            "enabled": tool_config.enabled,
+            "is_injectable": is_tool_injectable(tool_name),
+            "effective_line_length": effective_ll,
+            "config_source": tool_config.config_source,
+        }
+        if verbose:
+            native = _load_native_tool_config(tool_name)
+            tool_output["native_config"] = native if native else None
+            tool_output["defaults"] = config.get_tool_defaults(tool_name) or None
+
+        output["tool_configs"][tool_name] = tool_output
+
+    print(json.dumps(output, indent=2))
+
+
+def _output_rich(
+    console: Console,
+    config: LintroConfig,
+    verbose: bool,
+) -> None:
+    """Output configuration using Rich formatting.
+
+    Args:
+        console: Rich Console instance
+        config: LintroConfig instance from get_config()
+        verbose: Whether to show verbose output
+    """
+    # Header panel
+    console.print(
+        Panel.fit(
+            "[bold cyan]Lintro Configuration Report[/bold cyan]",
+            border_style="cyan",
+        ),
+    )
+    console.print()
+
+    # Config Source Section
+    config_source = config.config_path or "[dim]No config file (using defaults)[/dim]"
+    console.print(f"[bold]Config Source:[/bold] {config_source}")
+    console.print()
+
+    # Global Settings Section
+    global_table = Table(
+        title="Enforce Settings",
+        show_header=False,
+        box=None,
+    )
+    global_table.add_column("Setting", style="cyan", width=25)
+    global_table.add_column("Value", style="yellow")
+
+    line_length = config.enforce.line_length
+    global_table.add_row(
+        "line_length",
+        str(line_length) if line_length else "[dim]Not configured[/dim]",
+    )
+
+    target_python = config.enforce.target_python
+    global_table.add_row(
+        "target_python",
+        target_python if target_python else "[dim]Not configured[/dim]",
+    )
+
+    console.print(global_table)
+    console.print()
+
+    # Execution Settings Section
+    exec_table = Table(
+        title="Execution Settings",
+        show_header=False,
+        box=None,
+    )
+    exec_table.add_column("Setting", style="cyan", width=25)
+    exec_table.add_column("Value", style="yellow")
+
+    tool_order = config.execution.tool_order
+    if isinstance(tool_order, list):
+        order_strategy = "custom"
+        exec_table.add_row("tool_order", order_strategy)
+        exec_table.add_row("custom_order", ", ".join(tool_order))
+    else:
+        exec_table.add_row("tool_order", tool_order or "priority")
+
+    enabled_tools = config.execution.enabled_tools
+    exec_table.add_row(
+        "enabled_tools",
+        ", ".join(enabled_tools) if enabled_tools else "[dim]all[/dim]",
+    )
+    exec_table.add_row("fail_fast", str(config.execution.fail_fast))
+    exec_table.add_row("parallel", str(config.execution.parallel))
+
+    console.print(exec_table)
+    console.print()
+
+    # Tool Execution Order Section
+    tool_names = _get_all_tool_names()
+    ordered_tools = get_ordered_tools(
+        tool_names=tool_names,
+        tool_order=config.execution.tool_order,
+    )
+
+    order_table = Table(title="Tool Execution Order")
+    order_table.add_column("#", style="dim", justify="right", width=3)
+    order_table.add_column("Tool", style="cyan")
+    order_table.add_column("Priority", justify="center", style="yellow")
+    order_table.add_column("Type", style="green")
+    order_table.add_column("Enabled", justify="center")
+
+    for idx, tool_name in enumerate(ordered_tools, 1):
+        priority = get_tool_priority(tool_name)
+        injectable = is_tool_injectable(tool_name)
+        tool_type = "Syncable" if injectable else "Native only"
+        enabled = config.is_tool_enabled(tool_name)
+        enabled_display = "[green]✓[/green]" if enabled else "[red]✗[/red]"
+
+        order_table.add_row(
+            str(idx),
+            tool_name,
+            str(priority),
+            tool_type,
+            enabled_display,
+        )
+
+    console.print(order_table)
+    console.print()
+
+    # Per-Tool Configuration Section
+    config_table = Table(title="Per-Tool Configuration")
+    config_table.add_column("Tool", style="cyan")
+    config_table.add_column("Sync Status", justify="center")
+    config_table.add_column("Line Length", justify="center", style="yellow")
+    config_table.add_column("Config Source", style="dim")
+
+    if verbose:
+        config_table.add_column("Native Config", style="dim")
+
+    for tool_name in tool_names:
+        tool_config = config.get_tool_config(tool_name)
+        injectable = is_tool_injectable(tool_name)
+        status = (
+            "[green]✓ Syncable[/green]"
+            if injectable
+            else "[yellow]⚠ Native only[/yellow]"
+        )
+        effective_ll = config.get_effective_line_length(tool_name)
+        ll_display = str(effective_ll) if effective_ll else "[dim]default[/dim]"
+
+        cfg_source = tool_config.config_source or "[dim]auto[/dim]"
+
+        row = [tool_name, status, ll_display, cfg_source]
+
+        if verbose:
+            native = _load_native_tool_config(tool_name)
+            native_cfg = str(native) if native else "[dim]None[/dim]"
+            row.append(native_cfg)
+
+        config_table.add_row(*row)
+
+    console.print(config_table)
+    console.print()
+
+    # Warnings Section
+    warnings = validate_config_consistency()
+    if warnings:
+        console.print("[bold red]Configuration Warnings[/bold red]")
+        for warning in warnings:
+            console.print(f"  [yellow]⚠️[/yellow]  {warning}")
+        console.print()
+        console.print(
+            "[dim]Tools marked 'Native only' cannot be configured by Lintro. "
+            "Update their config files manually for consistency.[/dim]",
+        )
+    else:
+        console.print(
+            "[green]✅ All configurations are consistent![/green]",
+        )
+
+    console.print()
+
+    # Help text
+    console.print(
+        "[dim]Configure Lintro in .lintro-config.yaml:[/dim]",
+    )
+    console.print(
+        "[dim]  Run 'lintro init' to create a config file[/dim]",
+    )
+    console.print(
+        '[dim]  tool_order: "priority" | "alphabetical" | ["tool1", "tool2"][/dim]',
+    )

lintro/cli_utils/commands/format.py

@@ -140,7 +140,7 @@ def format_code_legacy(
         None: This function does not return a value.
 
     Raises:
-        Exception: If format fails for any reason.
+        RuntimeError: If format fails for any reason.
     """
     args: list[str] = []
     if paths:
@@ -163,5 +163,5 @@ def format_code_legacy(
     runner = CliRunner()
     result = runner.invoke(format_code, args)
     if result.exit_code != DEFAULT_EXIT_CODE:
-        raise Exception(f"Format failed: {result.output}")
+        raise RuntimeError(f"Format failed: {result.output}")
     return None