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

lintro/cli_utils/commands/init.py

@@ -0,0 +1,361 @@
+"""Init command for Lintro.
+
+Creates configuration files for Lintro and optionally native tool configs.
+"""
+
+import json
+from pathlib import Path
+
+import click
+from loguru import logger
+from rich.console import Console
+from rich.panel import Panel
+
+# Default Lintro config template
+DEFAULT_CONFIG_TEMPLATE = """\
+# Lintro Configuration
+# https://github.com/TurboCoder13/py-lintro
+#
+# Lintro acts as the master configuration source for all tools.
+# Native tool configs (e.g., .prettierrc) are ignored by default unless
+# explicitly referenced via config_source.
+
+enforce:
+  # Line length limit applied to all supporting tools
+  # Maps to: ruff line-length, black line-length, prettier printWidth, etc.
+  line_length: 88
+
+  # Python version target (e.g., "py313", "py312", "py310")
+  # Maps to: ruff target-version, black target-version
+  # Omit to let tools infer from requires-python in pyproject.toml
+  # target_python: "py310"
+
+execution:
+  # List of tools to run (empty = all available tools)
+  # enabled_tools: ["ruff", "prettier", "markdownlint", "yamllint"]
+  enabled_tools: []
+
+  # Execution order strategy:
+  # - "priority": Formatters before linters (default)
+  # - "alphabetical": Alphabetical order
+  # - ["tool1", "tool2", ...]: Custom order
+  tool_order: "priority"
+
+  # Stop on first tool failure
+  fail_fast: false
+
+tools:
+  # Ruff - Python linter and formatter
+  ruff:
+    enabled: true
+    # config_source: ".ruff.toml"  # Optional: inherit from native config
+    # Settings are passed directly to Ruff
+    # select: ["E", "F", "W", "I"]
+    # ignore: ["E501"]
+
+  # Black - Python formatter
+  black:
+    enabled: true
+    # config_source: "pyproject.toml"  # Optional: use [tool.black] section
+
+  # Prettier - Multi-language formatter
+  prettier:
+    enabled: true
+    # config_source: ".prettierrc"  # Optional: inherit from native config
+    # overrides:
+    #   printWidth: 88  # Override to match enforce line_length
+
+  # Markdownlint - Markdown linter
+  markdownlint:
+    enabled: true
+    # MD013 line_length is automatically synced from enforce.line_length
+
+  # Yamllint - YAML linter
+  yamllint:
+    enabled: true
+
+  # Bandit - Security linter
+  bandit:
+    enabled: true
+
+  # Hadolint - Dockerfile linter
+  hadolint:
+    enabled: true
+
+  # Actionlint - GitHub Actions linter
+  actionlint:
+    enabled: true
+
+  # Darglint - Docstring linter
+  darglint:
+    enabled: true
+"""
+
+MINIMAL_CONFIG_TEMPLATE = """\
+# Lintro Configuration (Minimal)
+# https://github.com/TurboCoder13/py-lintro
+
+enforce:
+  line_length: 88
+  # target_python: "py310"  # Omit to infer from requires-python
+
+execution:
+  tool_order: "priority"
+
+tools:
+  ruff:
+    enabled: true
+  black:
+    enabled: true
+  prettier:
+    enabled: true
+"""
+
+# Native config templates
+PRETTIERRC_TEMPLATE = {
+    "semi": True,
+    "singleQuote": True,
+    "tabWidth": 2,
+    "printWidth": 88,
+    "trailingComma": "es5",
+    "proseWrap": "always",
+    "overrides": [
+        {
+            "files": "*.md",
+            "options": {
+                "printWidth": 88,
+                "proseWrap": "always",
+            },
+        },
+    ],
+}
+
+PRETTIERIGNORE_TEMPLATE = """\
+# Ignore artifacts
+build
+dist
+node_modules
+.venv
+.lintro
+"""
+
+MARKDOWNLINT_TEMPLATE = {
+    "config": {
+        "MD013": {
+            "line_length": 88,
+            "code_blocks": False,
+            "tables": False,
+        },
+    },
+}
+
+
+def _write_file(
+    path: Path,
+    content: str,
+    console: Console,
+    force: bool,
+) -> bool:
+    """Write content to a file, handling existing files.
+
+    Args:
+        path: Path to write to.
+        content: Content to write.
+        console: Rich console for output.
+        force: Whether to overwrite existing files.
+
+    Returns:
+        bool: True if file was written, False if skipped.
+    """
+    if path.exists() and not force:
+        console.print(f"  [yellow]⏭️  Skipped {path} (already exists)[/yellow]")
+        return False
+
+    try:
+        path.write_text(content, encoding="utf-8")
+        console.print(f"  [green]✅ Created {path}[/green]")
+        return True
+    except (OSError, Exception) as e:
+        console.print(f"  [red]❌ Failed to write {path}: {e}[/red]")
+        return False
+
+
+def _write_json_file(
+    path: Path,
+    data: dict,
+    console: Console,
+    force: bool,
+) -> bool:
+    """Write JSON content to a file, handling existing files.
+
+    Args:
+        path: Path to write to.
+        data: Dictionary to serialize as JSON.
+        console: Rich console for output.
+        force: Whether to overwrite existing files.
+
+    Returns:
+        bool: True if file was written, False if skipped.
+    """
+    content = json.dumps(obj=data, indent=2) + "\n"
+    return _write_file(path=path, content=content, console=console, force=force)
+
+
+def _generate_native_configs(
+    console: Console,
+    force: bool,
+) -> list[str]:
+    """Generate native tool configuration files.
+
+    Args:
+        console: Rich console for output.
+        force: Whether to overwrite existing files.
+
+    Returns:
+        list[str]: List of created file names.
+    """
+    created: list[str] = []
+
+    console.print("\n[bold cyan]Generating native tool configs:[/bold cyan]")
+
+    # Prettier config
+    if _write_json_file(
+        path=Path(".prettierrc.json"),
+        data=PRETTIERRC_TEMPLATE,
+        console=console,
+        force=force,
+    ):
+        created.append(".prettierrc.json")
+
+    # Prettier ignore
+    if _write_file(
+        path=Path(".prettierignore"),
+        content=PRETTIERIGNORE_TEMPLATE,
+        console=console,
+        force=force,
+    ):
+        created.append(".prettierignore")
+
+    # Markdownlint config
+    if _write_json_file(
+        path=Path(".markdownlint-cli2.jsonc"),
+        data=MARKDOWNLINT_TEMPLATE,
+        console=console,
+        force=force,
+    ):
+        created.append(".markdownlint-cli2.jsonc")
+
+    return created
+
+
+@click.command("init")
+@click.option(
+    "--minimal",
+    "-m",
+    is_flag=True,
+    help="Create a minimal config file with fewer comments.",
+)
+@click.option(
+    "--force",
+    "-f",
+    is_flag=True,
+    help="Overwrite existing configuration files.",
+)
+@click.option(
+    "--output",
+    "-o",
+    type=click.Path(),
+    default=".lintro-config.yaml",
+    help="Output file path (default: .lintro-config.yaml).",
+)
+@click.option(
+    "--with-native-configs",
+    is_flag=True,
+    help="Also generate native tool configs (.prettierrc.json, etc.).",
+)
+def init_command(
+    minimal: bool,
+    force: bool,
+    output: str,
+    with_native_configs: bool,
+) -> None:
+    """Initialize Lintro configuration for your project.
+
+    Creates a scaffold configuration file with sensible defaults.
+    Lintro will use this file as the master configuration source,
+    ignoring native tool configs unless explicitly referenced.
+
+    Use --with-native-configs to also generate native tool configuration
+    files for IDE integration (e.g., Prettier extension, markdownlint extension).
+
+    Args:
+        minimal: Use minimal template with fewer comments.
+        force: Overwrite existing config file if it exists.
+        output: Output file path for the config file.
+        with_native_configs: Also generate native tool config files.
+
+    Raises:
+        SystemExit: If file exists and --force not provided, or write fails.
+    """
+    console = Console()
+    output_path = Path(output)
+    created_files: list[str] = []
+
+    # Check if main config file already exists
+    if output_path.exists() and not force:
+        console.print(
+            f"[red]Error: {output_path} already exists. "
+            "Use --force to overwrite.[/red]",
+        )
+        raise SystemExit(1)
+
+    # Select template
+    template = MINIMAL_CONFIG_TEMPLATE if minimal else DEFAULT_CONFIG_TEMPLATE
+
+    # Write main config file
+    try:
+        output_path.write_text(template, encoding="utf-8")
+        created_files.append(str(output_path))
+        logger.debug(f"Created config file: {output_path.resolve()}")
+
+    except (OSError, PermissionError) as e:
+        console.print(f"[red]Error: Failed to write {output_path}: {e}[/red]")
+        raise SystemExit(1) from e
+
+    # Generate native configs if requested
+    if with_native_configs:
+        native_files = _generate_native_configs(console=console, force=force)
+        created_files.extend(native_files)
+
+    # Success panel
+    console.print()
+    if len(created_files) == 1:
+        console.print(
+            Panel.fit(
+                f"[bold green]✅ Created {output_path}[/bold green]",
+                border_style="green",
+            ),
+        )
+    else:
+        files_list = "\n".join(f"  • {f}" for f in created_files)
+        msg = f"[bold green]✅ Created {len(created_files)} files:[/bold green]"
+        console.print(
+            Panel.fit(
+                f"{msg}\n{files_list}",
+                border_style="green",
+            ),
+        )
+
+    console.print()
+
+    # Next steps
+    console.print("[bold cyan]Next steps:[/bold cyan]")
+    console.print("  [dim]1.[/dim] Review and customize the configuration")
+    console.print(
+        "  [dim]2.[/dim] Run [cyan]lintro config[/cyan] to view config",
+    )
+    console.print("  [dim]3.[/dim] Run [cyan]lintro check .[/cyan] to lint")
+    if with_native_configs:
+        console.print(
+            "  [dim]3.[/dim] Commit the config files to your repository",
+        )

lintro/cli_utils/commands/list_tools.py

@@ -3,11 +3,46 @@
 This module provides the core logic for the 'list_tools' command.
 """
 
+from typing import Any
+
 import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
 
 from lintro.enums.action import Action
 from lintro.tools import tool_manager
+from lintro.tools.tool_enum import ToolEnum
 from lintro.utils.console_logger import get_tool_emoji
+from lintro.utils.unified_config import get_tool_priority, is_tool_injectable
+
+
+def _resolve_conflicts(
+    tool_config: Any,
+    name_to_enum_map: dict[str, ToolEnum],
+    available_tools: dict[ToolEnum, Any],
+) -> list[str]:
+    """Resolve conflict names for a tool.
+
+    Args:
+        tool_config: Tool configuration object.
+        name_to_enum_map: Mapping of tool names to ToolEnum.
+        available_tools: Dictionary of available tools.
+
+    Returns:
+        List of conflict tool names.
+    """
+    conflict_names: list[str] = []
+    if hasattr(tool_config, "conflicts_with") and tool_config.conflicts_with:
+        for conflict in tool_config.conflicts_with:
+            conflict_enum: ToolEnum | None = None
+            if isinstance(conflict, str):
+                conflict_enum = name_to_enum_map.get(conflict.lower())
+            elif isinstance(conflict, ToolEnum):
+                conflict_enum = conflict
+            if conflict_enum is not None and conflict_enum in available_tools:
+                conflict_names.append(conflict_enum.name.lower())
+    return conflict_names
 
 
 @click.command("list-tools")
@@ -44,24 +79,145 @@ def list_tools(
         output: Output file path.
         show_conflicts: Whether to show potential conflicts between tools.
     """
+    console = Console()
     available_tools = tool_manager.get_available_tools()
     check_tools = tool_manager.get_check_tools()
     fix_tools = tool_manager.get_fix_tools()
 
-    output_lines = []
+    # Header panel
+    console.print(
+        Panel.fit(
+            "[bold cyan]🔧 Available Tools[/bold cyan]",
+            border_style="cyan",
+        ),
+    )
+    console.print()
+
+    # Main tools table
+    table = Table(title="Tool Details")
+    table.add_column("Tool", style="cyan", no_wrap=True)
+    table.add_column("Description", style="white", max_width=40)
+    table.add_column("Capabilities", style="green")
+    table.add_column("Priority", justify="center", style="yellow")
+    table.add_column("Type", style="magenta")
+
+    if show_conflicts:
+        table.add_column("Conflicts", style="red")
+
+    # Build name-to-enum map for conflict resolution
+    name_to_enum_map = {t.name.lower(): t for t in ToolEnum}
+
+    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
+        capabilities: list[str] = []
+        if tool_enum in check_tools:
+            capabilities.append("check")
+        if tool_enum in fix_tools:
+            capabilities.append("fix")
+        caps_display = ", ".join(capabilities) if capabilities else "-"
+
+        # Priority and type
+        priority = get_tool_priority(tool_name)
+        injectable = is_tool_injectable(tool_name)
+        tool_type = "Syncable" if injectable else "Native only"
+
+        row = [
+            f"{emoji} {tool_name}",
+            tool_description,
+            caps_display,
+            str(priority),
+            tool_type,
+        ]
+
+        # Conflicts
+        if show_conflicts:
+            conflict_names = _resolve_conflicts(
+                tool_config=tool.config,
+                name_to_enum_map=name_to_enum_map,
+                available_tools=available_tools,
+            )
+            row.append(", ".join(conflict_names) if conflict_names else "-")
+
+        table.add_row(*row)
+
+    console.print(table)
+    console.print()
+
+    # Summary table
+    summary_table = Table(
+        title="Summary",
+        show_header=False,
+        box=None,
+    )
+    summary_table.add_column("Metric", style="cyan", width=20)
+    summary_table.add_column("Count", style="yellow", justify="right")
+
+    summary_table.add_row("📊 Total tools", str(len(available_tools)))
+    summary_table.add_row("🔍 Check tools", str(len(check_tools)))
+    summary_table.add_row("🔧 Fix tools", str(len(fix_tools)))
+
+    console.print(summary_table)
+
+    # Write to file if specified
+    if output:
+        try:
+            # For file output, use plain text format
+            output_lines = _generate_plain_text_output(
+                available_tools=available_tools,
+                check_tools=check_tools,
+                fix_tools=fix_tools,
+                show_conflicts=show_conflicts,
+            )
+            with open(output, "w", encoding="utf-8") as f:
+                f.write("\n".join(output_lines) + "\n")
+            console.print()
+            console.print(f"[green]✅ Output written to: {output}[/green]")
+        except OSError as e:
+            console.print(f"[red]Error writing to file {output}: {e}[/red]")
+
+
+def _generate_plain_text_output(
+    available_tools: dict[ToolEnum, Any],
+    check_tools: dict[ToolEnum, Any],
+    fix_tools: dict[ToolEnum, Any],
+    show_conflicts: bool,
+) -> list[str]:
+    """Generate plain text output for file writing.
+
+    Args:
+        available_tools: Dictionary of available tools.
+        check_tools: Dictionary of check-capable tools.
+        fix_tools: Dictionary of fix-capable tools.
+        show_conflicts: Whether to include conflict information.
 
-    # Create header with emojis
+    Returns:
+        List of output lines.
+    """
+    output_lines: list[str] = []
     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(border)
+    output_lines.append("Available Tools")
+    output_lines.append(border)
     output_lines.append("")
 
+    name_to_enum_map = {t.name.lower(): t for t in ToolEnum}
+
     for tool_enum, tool in available_tools.items():
         tool_name = tool_enum.name.lower()
-        tool_description = getattr(tool.config, "description", tool.__class__.__name__)
+        tool_description = getattr(
+            tool.config,
+            "description",
+            tool.__class__.__name__,
+        )
         emoji = get_tool_emoji(tool_name)
 
         capabilities: list[str] = []
@@ -70,45 +226,27 @@ def list_tools(
         if tool_enum in fix_tools:
             capabilities.append(Action.FIX.value)
 
+        capabilities_display = ", ".join(capabilities) if capabilities else "-"
+
         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(f"  Capabilities: {capabilities_display}")
+
+        if show_conflicts:
+            conflict_names = _resolve_conflicts(
+                tool_config=tool.config,
+                name_to_enum_map=name_to_enum_map,
+                available_tools=available_tools,
+            )
+            if conflict_names:
+                output_lines.append(f"  Conflicts with: {', '.join(conflict_names)}")
 
         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(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 OSError as e:
-            error_msg = f"Error writing to file {output}: {e}"
-            click.echo(error_msg, err=True)
+    return output_lines