feat(mappings): add four-tier macOS-to-nix-darwin mapping layer

src/mac2nix/cli.py

@@ -5,19 +5,106 @@
 import asyncio
 import time
 import uuid
+from collections import Counter
+from collections.abc import Sequence
 from pathlib import Path
 
 import click
-from rich.console import Console
-from rich.progress import BarColumn, MofNCompleteColumn, Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+from rich.console import Console, Group, RenderableType
+from rich.live import Live
+from rich.spinner import Spinner
+from rich.table import Table
+from rich.text import Text
 
 from mac2nix.models.system_state import SystemState
 from mac2nix.orchestrator import run_scan
+from mac2nix.scan_report import ScannerOutcome, ScannerStatus, capture_scanner_logs, get_remediation_hint
 from mac2nix.scanners import get_all_scanners
 from mac2nix.vm.discovery import DiscoveryRunner
 from mac2nix.vm.manager import TartVMManager
 from mac2nix.vm.validator import Validator
 
+_STATUS_ICONS: dict[ScannerStatus, tuple[str, str]] = {
+    ScannerStatus.SUCCESS: ("✓", "green"),
+    ScannerStatus.WARNING: ("⚠", "yellow"),
+    ScannerStatus.ERROR: ("✗", "red"),
+    ScannerStatus.SKIPPED: ("⊘", "dim"),
+}
+
+_TALLY_LABELS: dict[ScannerStatus, str] = {
+    ScannerStatus.SUCCESS: "success",
+    ScannerStatus.WARNING: "completed with warnings",
+    ScannerStatus.ERROR: "failed",
+    ScannerStatus.SKIPPED: "skipped",
+}
+
+
+def _status_icon(status: ScannerStatus) -> tuple[str, str]:
+    """Return (icon, style) for a scanner's status."""
+    return _STATUS_ICONS[status]
+
+
+def _message_lines(message: str) -> list[Text]:
+    """Render a warning/error message plus its remediation hint (if any).
+
+    Returned as standalone Text objects (not table cells) so they wrap at the
+    full console width instead of being squeezed into a narrow shared column.
+    A message with embedded newlines (e.g. a "...\\nstderr: ..." continuation
+    from run_command()) gets each continuation line indented to nest under the
+    first, rather than resetting to the left margin.
+    """
+    first, *continuation = message.split("\n")
+    lines = [Text(f"  ↳ {first}", style="dim")]
+    lines.extend(Text(f"     {line}", style="dim") for line in continuation)
+    hint = get_remediation_hint(message)
+    if hint is not None:
+        lines.append(Text(f"     → {hint}", style="dim italic"))
+    return lines
+
+
+def _build_scan_table(outcomes: dict[str, ScannerOutcome], order: Sequence[str]) -> Group:
+    """Render one compact summary line per scanner, with full-width lines for warnings/errors.
+
+    Each scanner gets its own small grid for the summary line (status icon, name,
+    elapsed, detail) so that line's width is driven only by scanner names, never
+    by warning/error text -- that text is rendered separately, below, as
+    unconstrained lines so it wraps at the full console width instead of forcing
+    every summary line wide.
+    """
+    name_width = max((len(name) for name in order), default=0)
+    renderables: list[RenderableType] = []
+
+    for name in order:
+        grid = Table.grid(padding=(0, 1))
+        grid.add_column(width=2, justify="center")
+        grid.add_column(width=name_width)
+        grid.add_column(width=6, justify="right")
+        grid.add_column()
+
+        outcome = outcomes.get(name)
+        if outcome is None:
+            grid.add_row(Spinner("dots"), name, "", "")
+            renderables.append(grid)
+            continue
+
+        icon, style = _status_icon(outcome.status)
+        detail = ""
+        if outcome.status is ScannerStatus.WARNING:
+            detail = f"{len(outcome.warnings)} warning(s)"
+        elif outcome.status is ScannerStatus.ERROR:
+            detail = "error"
+
+        grid.add_row(Text(icon, style=style), name, f"{outcome.elapsed:.1f}s", detail)
+        renderables.append(grid)
+
+        if outcome.status in (ScannerStatus.WARNING, ScannerStatus.ERROR):
+            for warning in outcome.warnings:
+                renderables.extend(_message_lines(warning))
+            if outcome.status is ScannerStatus.ERROR and outcome.error is not None:
+                renderables.extend(_message_lines(outcome.error))
+
+    return Group(*renderables)
+
 
 @click.group()
 @click.version_option()
@@ -54,52 +141,56 @@ def scan(output: Path | None, selected_scanners: tuple[str, ...]) -> None:
             available = ", ".join(sorted(all_names))
             raise click.UsageError(f"Unknown scanner(s): {', '.join(unknown)}. Available: {available}")
 
-    total = len(scanners) if scanners is not None else len(all_names)
+    scanner_names: list[str] = scanners if scanners is not None else all_names
 
-    completed: int = 0
+    outcomes: dict[str, ScannerOutcome] = {}
     start = time.monotonic()
 
-    with Progress(
-        SpinnerColumn(),
-        TextColumn("[progress.description]{task.description}"),
-        BarColumn(),
-        MofNCompleteColumn(),
-        TimeElapsedColumn(),
-        console=Console(stderr=True),
-        transient=True,
-        redirect_stdout=False,
-        redirect_stderr=False,
-    ) as progress:
-        task_id = progress.add_task("Scanning...", total=total)
-
-        def progress_callback(name: str) -> None:
-            nonlocal completed
-            completed += 1
-            progress.advance(task_id)
-            progress.update(task_id, description=f"[bold cyan]{name}[/] done")
+    with (
+        capture_scanner_logs() as log_handler,
+        Live(
+            _build_scan_table(outcomes, scanner_names),
+            console=Console(stderr=True),
+            refresh_per_second=8,
+            transient=False,
+        ) as live,
+    ):
+
+        def progress_callback(outcome: ScannerOutcome) -> None:
+            outcomes[outcome.name] = outcome
+            live.update(_build_scan_table(outcomes, scanner_names))
 
         try:
-            state = asyncio.run(run_scan(scanners=scanners, progress_callback=progress_callback))
+            state = asyncio.run(
+                run_scan(scanners=scanners, progress_callback=progress_callback, log_handler=log_handler)
+            )
         except RuntimeError as e:
             raise click.ClickException(str(e)) from e
 
     elapsed = time.monotonic() - start
-    scanner_count = completed
+
+    if log_handler.unattributed:
+        click.echo("General warnings:", err=True)
+        for warning in log_handler.unattributed:
+            click.echo(f"  {warning}", err=True)
+            hint = get_remediation_hint(warning)
+            if hint is not None:
+                click.echo(f"    → {hint}", err=True)
+
+    tally_counts = Counter(outcome.status for outcome in outcomes.values())
+    tally = ", ".join(
+        f"{tally_counts[status]} {_TALLY_LABELS[status]}" for status in ScannerStatus if tally_counts.get(status, 0) > 0
+    )
 
     json_output = state.to_json()
+    summary = f"Scanned {len(outcomes)} scanner(s) in {elapsed:.1f}s ({tally})"
 
     if output is not None:
         output.parent.mkdir(parents=True, exist_ok=True)
         output.write_text(json_output)
-        click.echo(
-            f"Scanned {scanner_count} scanner(s) in {elapsed:.1f}s — wrote {output}",
-            err=True,
-        )
+        click.echo(f"{summary} — wrote {output}", err=True)
     else:
-        click.echo(
-            f"Scanned {scanner_count} scanner(s) in {elapsed:.1f}s",
-            err=True,
-        )
+        click.echo(summary, err=True)
         click.echo(json_output)
 
 

src/mac2nix/mappings/__init__.py

@@ -0,0 +1,112 @@
+"""Mapping layer: macOS scan data to nix-darwin option paths.
+
+Re-exports the public API of all nine mapping modules. `app_to_package`'s
+`classify_app(name: str) -> AppClassification | None` (a raw name lookup) is
+deliberately NOT re-exported at this level -- it would shadow this package's
+own `classify_app(app: InstalledApp) -> ClassificationResult` (the
+classifier's per-InstalledApp routing function). Reach it via
+`mac2nix.mappings.app_to_package.classify_app` if needed.
+"""
+
+from __future__ import annotations
+
+from mac2nix.mappings.app_config_registry import APP_CONFIG_REGISTRY, AppConfigInfo, get_app_config
+from mac2nix.mappings.app_to_hm import APP_TO_HM_MODULE, HMModuleInfo, get_hm_module
+from mac2nix.mappings.app_to_package import AppClassification, normalize_app_name
+from mac2nix.mappings.brew_to_nixpkgs import (
+    BREW_TO_NIXPKGS,
+    VERSION_MANAGER_FORMULAE,
+    NixpkgsEquivalent,
+    get_nixpkgs_equivalent,
+    is_unnecessary_in_nix,
+)
+from mac2nix.mappings.classifier import (
+    ClassificationResult,
+    ClassificationTier,
+    classify_app,
+    classify_app_config,
+    classify_brew_formula,
+    classify_dotfile,
+    classify_font,
+    classify_launch_agent,
+    classify_network_setting,
+    classify_preference,
+    classify_security_setting,
+    classify_shell_setting,
+    classify_system_setting,
+)
+from mac2nix.mappings.defaults_to_nix import (
+    DEFAULTS_TO_NIX,
+    DOMAIN_ALIASES,
+    NixOption,
+    get_nix_option,
+    get_unmapped_keys,
+)
+from mac2nix.mappings.dotfile_to_hm import DOTFILE_TO_HM, get_hm_program
+from mac2nix.mappings.ephemeral_filter import filter_ephemeral, is_ephemeral
+from mac2nix.mappings.non_defaults_to_nix import (
+    FONT_TO_NIXPKGS,
+    LAUNCHD_KEYS_TO_DROP,
+    LAUNCHD_LABEL_TO_SERVICE,
+    NETWORKING_MAP,
+    POWER_SETTING_MAP,
+    SECURITY_MAP,
+    SHELL_PROGRAM_MAP,
+    TIMEZONE_NIX_OPTION,
+    get_font_nixpkgs,
+    get_launchd_service,
+    get_power_nix_option,
+    get_shell_program,
+    is_launchd_key_droppable,
+)
+
+__all__ = [
+    "APP_CONFIG_REGISTRY",
+    "APP_TO_HM_MODULE",
+    "BREW_TO_NIXPKGS",
+    "DEFAULTS_TO_NIX",
+    "DOMAIN_ALIASES",
+    "DOTFILE_TO_HM",
+    "FONT_TO_NIXPKGS",
+    "LAUNCHD_KEYS_TO_DROP",
+    "LAUNCHD_LABEL_TO_SERVICE",
+    "NETWORKING_MAP",
+    "POWER_SETTING_MAP",
+    "SECURITY_MAP",
+    "SHELL_PROGRAM_MAP",
+    "TIMEZONE_NIX_OPTION",
+    "VERSION_MANAGER_FORMULAE",
+    "AppClassification",
+    "AppConfigInfo",
+    "ClassificationResult",
+    "ClassificationTier",
+    "HMModuleInfo",
+    "NixOption",
+    "NixpkgsEquivalent",
+    "classify_app",
+    "classify_app_config",
+    "classify_brew_formula",
+    "classify_dotfile",
+    "classify_font",
+    "classify_launch_agent",
+    "classify_network_setting",
+    "classify_preference",
+    "classify_security_setting",
+    "classify_shell_setting",
+    "classify_system_setting",
+    "filter_ephemeral",
+    "get_app_config",
+    "get_font_nixpkgs",
+    "get_hm_module",
+    "get_hm_program",
+    "get_launchd_service",
+    "get_nix_option",
+    "get_nixpkgs_equivalent",
+    "get_power_nix_option",
+    "get_shell_program",
+    "get_unmapped_keys",
+    "is_ephemeral",
+    "is_launchd_key_droppable",
+    "is_unnecessary_in_nix",
+    "normalize_app_name",
+]