woolly 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

woolly/reporters/__init__.py

@@ -6,6 +6,7 @@ To add a new format, create a module in this directory that defines a class
 inheriting from Reporter and add it to REPORTERS dict.
 """
 
+from pathlib import Path
 from typing import Optional
 
 from pydantic import BaseModel, Field
@@ -15,6 +16,7 @@ from woolly.reporters.base import ReportData, Reporter, strip_markup
 from woolly.reporters.json import JsonReporter
 from woolly.reporters.markdown import MarkdownReporter
 from woolly.reporters.stdout import StdoutReporter
+from woolly.reporters.template import TemplateReporter
 
 
 class ReporterInfo(BaseModel):
@@ -32,6 +34,7 @@ REPORTERS: dict[str, type[Reporter]] = {
     "stdout": StdoutReporter,
     "markdown": MarkdownReporter,
     "json": JsonReporter,
+    "template": TemplateReporter,
 }
 
 # Aliases for convenience
@@ -39,11 +42,16 @@ ALIASES: dict[str, str] = {
     "md": "markdown",
     "console": "stdout",
     "terminal": "stdout",
+    "tpl": "template",
+    "jinja": "template",
+    "jinja2": "template",
 }
 
 
 def get_reporter(
-    format_name: str, console: Optional[Console] = None
+    format_name: str,
+    console: Optional[Console] = None,
+    template_path: Optional[Path] = None,
 ) -> Optional[Reporter]:
     """
     Get an instantiated reporter for the specified format.
@@ -51,6 +59,7 @@ def get_reporter(
     Args:
         format_name: Format identifier or alias (e.g., "json", "markdown", "md")
         console: Console instance for stdout reporter.
+        template_path: Path to template file for template reporter.
 
     Returns:
         Instantiated Reporter, or None if not found.
@@ -68,6 +77,10 @@ def get_reporter(
     if format_name == "stdout" and console:
         return StdoutReporter(console=console)
 
+    # TemplateReporter needs a template path
+    if format_name == "template":
+        return TemplateReporter(template_path=template_path)
+
     return reporter_class()
 
 
@@ -104,6 +117,7 @@ __all__ = [
     "StdoutReporter",
     "MarkdownReporter",
     "JsonReporter",
+    "TemplateReporter",
     "get_reporter",
     "list_reporters",
     "get_available_formats",

woolly/reporters/base.py

@@ -51,6 +51,9 @@ class ReportData(BaseModel):
     language: str
     registry: str
 
+    # License
+    root_license: Optional[str] = None
+
     # Statistics
     total_dependencies: int
     packaged_count: int
@@ -65,6 +68,21 @@ class ReportData(BaseModel):
     optional_missing: int = 0
     optional_missing_packages: list[str] = Field(default_factory=list)
 
+    # Dev dependency statistics
+    dev_dependencies: list[dict] = Field(default_factory=list)
+    dev_total: int = 0
+    dev_packaged: int = 0
+    dev_missing: int = 0
+
+    # Build dependency statistics
+    build_dependencies: list[dict] = Field(default_factory=list)
+    build_total: int = 0
+    build_packaged: int = 0
+    build_missing: int = 0
+
+    # Features / extras
+    features: list[Any] = Field(default_factory=list)
+
     # Full tree for detailed reports
     tree: Any  # Rich Tree object - not JSON serializable
 
@@ -73,6 +91,13 @@ class ReportData(BaseModel):
     max_depth: int = 50
     version: Optional[str] = None
 
+    # Fedora targeting
+    fedora_release: Optional[str] = None
+    fedora_repos: Optional[list[str]] = None
+
+    # Display options
+    missing_only: bool = False
+
     @cached_property
     def required_missing_packages(self) -> set[str]:
         """Get the set of required (non-optional) missing packages."""

woolly/reporters/json.py

@@ -18,6 +18,7 @@ class TreeNodeData(BaseModel):
     raw: str
     name: Optional[str] = None
     version: Optional[str] = None
+    license: Optional[str] = None
     optional: bool = False
     status: Optional[str] = None
     is_packaged: Optional[bool] = None
@@ -34,9 +35,28 @@ class ReportMetadata(BaseModel):
     root_package: str
     language: str
     registry: str
+    license: Optional[str] = None
     version: Optional[str] = None
     max_depth: int
     include_optional: bool
+    missing_only: bool = False
+
+
+class DevBuildDepData(BaseModel):
+    """Structured data for a dev or build dependency."""
+
+    name: str
+    version_requirement: str
+    is_packaged: bool
+    fedora_versions: list[str] = Field(default_factory=list)
+    fedora_packages: list[str] = Field(default_factory=list)
+
+
+class FeatureData(BaseModel):
+    """Structured data for a feature flag or extra."""
+
+    name: str
+    dependencies: list[str] = Field(default_factory=list)
 
 
 class ReportSummary(BaseModel):
@@ -46,6 +66,8 @@ class ReportSummary(BaseModel):
     packaged_count: int
     missing_count: int
     optional: "OptionalSummary"
+    dev: "DevBuildSummary"
+    build: "DevBuildSummary"
 
 
 class OptionalSummary(BaseModel):
@@ -56,6 +78,14 @@ class OptionalSummary(BaseModel):
     missing: int
 
 
+class DevBuildSummary(BaseModel):
+    """Dev or build dependency statistics."""
+
+    total: int
+    packaged: int
+    missing: int
+
+
 class JsonReport(BaseModel):
     """Complete JSON report structure."""
 
@@ -64,6 +94,9 @@ class JsonReport(BaseModel):
     missing_packages: list[str]
     missing_optional_packages: list[str]
     packaged_packages: list[str]
+    features: list[FeatureData] = Field(default_factory=list)
+    dev_dependencies: list[DevBuildDepData] = Field(default_factory=list)
+    build_dependencies: list[DevBuildDepData] = Field(default_factory=list)
     dependency_tree: TreeNodeData
 
 
@@ -77,15 +110,53 @@ class JsonReporter(Reporter):
 
     def generate(self, data: ReportData) -> str:
         """Generate JSON report content."""
+        # Convert features to FeatureData
+        features_data = []
+        for f in data.features:
+            if hasattr(f, "name"):
+                features_data.append(
+                    FeatureData(name=f.name, dependencies=f.dependencies)
+                )
+            else:
+                features_data.append(
+                    FeatureData(
+                        name=f.get("name", ""), dependencies=f.get("dependencies", [])
+                    )
+                )
+
+        # Convert dev/build deps to DevBuildDepData
+        dev_deps_data = [
+            DevBuildDepData(
+                name=d["name"],
+                version_requirement=d["version_requirement"],
+                is_packaged=d["is_packaged"],
+                fedora_versions=d.get("fedora_versions", []),
+                fedora_packages=d.get("fedora_packages", []),
+            )
+            for d in data.dev_dependencies
+        ]
+        build_deps_data = [
+            DevBuildDepData(
+                name=d["name"],
+                version_requirement=d["version_requirement"],
+                is_packaged=d["is_packaged"],
+                fedora_versions=d.get("fedora_versions", []),
+                fedora_packages=d.get("fedora_packages", []),
+            )
+            for d in data.build_dependencies
+        ]
+
         report = JsonReport(
             metadata=ReportMetadata(
                 generated_at=data.timestamp.isoformat(),
                 root_package=data.root_package,
                 language=data.language,
                 registry=data.registry,
+                license=data.root_license,
                 version=data.version,
                 max_depth=data.max_depth,
                 include_optional=data.include_optional,
+                missing_only=data.missing_only,
             ),
             summary=ReportSummary(
                 total_dependencies=data.total_dependencies,
@@ -96,10 +167,26 @@ class JsonReporter(Reporter):
                     packaged=data.optional_packaged,
                     missing=data.optional_missing,
                 ),
+                dev=DevBuildSummary(
+                    total=data.dev_total,
+                    packaged=data.dev_packaged,
+                    missing=data.dev_missing,
+                ),
+                build=DevBuildSummary(
+                    total=data.build_total,
+                    packaged=data.build_packaged,
+                    missing=data.build_missing,
+                ),
             ),
             missing_packages=sorted(data.required_missing_packages),
             missing_optional_packages=sorted(data.optional_missing_set),
-            packaged_packages=sorted(data.unique_packaged_packages),
+            # Skip packaged packages list when missing_only mode is enabled
+            packaged_packages=[]
+            if data.missing_only
+            else sorted(data.unique_packaged_packages),
+            features=features_data,
+            dev_dependencies=dev_deps_data,
+            build_dependencies=build_deps_data,
             dependency_tree=self._tree_to_model(data.tree),
         )
 
@@ -128,10 +215,22 @@ class JsonReporter(Reporter):
         # Check if this is an optional dependency
         node.optional = "(optional)" in clean_label
 
+        # Try to extract license from the label (format: "(LICENSE)" before optional/status)
+        license_match = re.search(
+            r"v[\d.]+\s*\(([^)]+)\)\s*(?:\(optional\))?\s*•", clean_label
+        )
+        if license_match:
+            potential_license = license_match.group(1)
+            # Make sure it's not a version number or "optional"
+            if potential_license != "optional" and not re.match(
+                r"^[\d., ]+$", potential_license
+            ):
+                node.license = potential_license
+
         # Try to extract package name and version
-        # Pattern: "package_name vX.Y.Z (optional) • status" or "package_name vX.Y.Z • status"
+        # Pattern: "package_name vX.Y.Z (LICENSE) (optional) • status" or "package_name vX.Y.Z • status"
         match = re.match(
-            r"^(\S+)\s*(?:v([\d.]+))?\s*(?:\(optional\))?\s*•\s*(.+)$",
+            r"^(\S+)\s*(?:v([\d.]+))?\s*(?:\([^)]*\))?\s*(?:\(optional\))?\s*•\s*(.+)$",
             clean_label.strip(),
         )
         if match:

woolly/reporters/markdown.py

@@ -25,10 +25,14 @@ class MarkdownReporter(Reporter):
         lines.append(f"**Generated:** {data.timestamp.strftime('%Y-%m-%d %H:%M:%S')}")
         lines.append(f"**Language:** {data.language}")
         lines.append(f"**Registry:** {data.registry}")
+        if data.root_license:
+            lines.append(f"**License:** {data.root_license}")
         if data.version:
             lines.append(f"**Version:** {data.version}")
         if data.include_optional:
             lines.append("**Include optional:** Yes")
+        if data.missing_only:
+            lines.append("**Missing only:** Yes")
         lines.append("")
 
         # Summary
@@ -45,8 +49,77 @@ class MarkdownReporter(Reporter):
             lines.append(f"| Optional dependencies | {data.optional_total} |")
             lines.append(f"| Optional - Packaged | {data.optional_packaged} |")
             lines.append(f"| Optional - Missing | {data.optional_missing} |")
+
+        # Dev dependency stats
+        if data.dev_total > 0:
+            lines.append(f"| Dev dependencies | {data.dev_total} |")
+            lines.append(f"| Dev - Packaged | {data.dev_packaged} |")
+            lines.append(f"| Dev - Missing | {data.dev_missing} |")
+
+        # Build dependency stats
+        if data.build_total > 0:
+            lines.append(f"| Build dependencies | {data.build_total} |")
+            lines.append(f"| Build - Packaged | {data.build_packaged} |")
+            lines.append(f"| Build - Missing | {data.build_missing} |")
         lines.append("")
 
+        # Features / Extras
+        if data.features:
+            lines.append("## Features / Extras")
+            lines.append("")
+            for feature in data.features:
+                feature_name = (
+                    feature.name
+                    if hasattr(feature, "name")
+                    else feature.get("name", "")
+                )
+                deps = (
+                    feature.dependencies
+                    if hasattr(feature, "dependencies")
+                    else feature.get("dependencies", [])
+                )
+                if deps:
+                    lines.append(f"- **{feature_name}**: {', '.join(deps)}")
+                else:
+                    lines.append(f"- **{feature_name}**")
+            lines.append("")
+
+        # Dev dependencies
+        if data.dev_dependencies:
+            lines.append("## Dev Dependencies")
+            lines.append("")
+            lines.append("| Package | Version Req | Fedora Status |")
+            lines.append("|---------|-------------|---------------|")
+            for dep in data.dev_dependencies:
+                status = "Packaged" if dep["is_packaged"] else "Missing"
+                ver_info = (
+                    f" ({', '.join(dep['fedora_versions'])})"
+                    if dep.get("fedora_versions")
+                    else ""
+                )
+                lines.append(
+                    f"| `{dep['name']}` | {dep['version_requirement']} | {status}{ver_info} |"
+                )
+            lines.append("")
+
+        # Build dependencies
+        if data.build_dependencies:
+            lines.append("## Build Dependencies")
+            lines.append("")
+            lines.append("| Package | Version Req | Fedora Status |")
+            lines.append("|---------|-------------|---------------|")
+            for dep in data.build_dependencies:
+                status = "Packaged" if dep["is_packaged"] else "Missing"
+                ver_info = (
+                    f" ({', '.join(dep['fedora_versions'])})"
+                    if dep.get("fedora_versions")
+                    else ""
+                )
+                lines.append(
+                    f"| `{dep['name']}` | {dep['version_requirement']} | {status}{ver_info} |"
+                )
+            lines.append("")
+
         # Missing packages - use computed properties from ReportData
         required_missing = data.required_missing_packages
         optional_missing = data.optional_missing_set
@@ -69,8 +142,8 @@ class MarkdownReporter(Reporter):
                 lines.append(f"- `{name}` *(optional)*")
             lines.append("")
 
-        # Packaged packages - use computed property
-        if data.unique_packaged_packages:
+        # Packaged packages - use computed property (skip if missing_only mode)
+        if data.unique_packaged_packages and not data.missing_only:
             lines.append("## Packaged Packages")
             lines.append("")
             lines.append("The following packages are already available in Fedora:")
@@ -79,13 +152,14 @@ class MarkdownReporter(Reporter):
                 lines.append(f"- `{name}`")
             lines.append("")
 
-        # Dependency tree
-        lines.append("## Dependency Tree")
-        lines.append("")
-        lines.append("```")
-        lines.append(self._tree_to_text(data.tree))
-        lines.append("```")
-        lines.append("")
+        # Dependency tree (skip if missing_only mode)
+        if not data.missing_only:
+            lines.append("## Dependency Tree")
+            lines.append("")
+            lines.append("```")
+            lines.append(self._tree_to_text(data.tree))
+            lines.append("```")
+            lines.append("")
 
         return "\n".join(lines)
 

woolly/reporters/stdout.py

@@ -2,14 +2,21 @@
 Standard output reporter using Rich.
 
 This is the default reporter that outputs to the console with colors and formatting.
+Uses a grid layout with side-by-side panels on wide terminals (>= 100 cols)
+and falls back to stacked layout on narrow terminals.
 """
 
 from rich import box
 from rich.console import Console
+from rich.panel import Panel
 from rich.table import Table
+from rich.text import Text
 
 from woolly.reporters.base import ReportData, Reporter
 
+# Minimum terminal width for side-by-side layout
+_MIN_SIDE_BY_SIDE_WIDTH = 100
+
 
 class StdoutReporter(Reporter):
     """Reporter that outputs to stdout using Rich formatting."""
@@ -22,54 +29,180 @@ class StdoutReporter(Reporter):
     def __init__(self, console: Console | None = None):
         self.console = console or Console()
 
-    def generate(self, data: ReportData) -> str:
-        """Generate and print the report to stdout."""
-        # Print summary table
-        table = Table(
-            title=f"Dependency Summary for '{data.root_package}' ({data.language})",
-            box=box.ROUNDED,
-        )
+    def _print_side_by_side(self, left, right) -> None:
+        """Print two renderables side by side, or stacked on narrow terminals."""
+        if self.console.width >= _MIN_SIDE_BY_SIDE_WIDTH:
+            grid = Table.grid(padding=(0, 1), expand=True)
+            grid.add_column(ratio=1)
+            grid.add_column(ratio=1)
+            grid.add_row(left, right)
+            self.console.print(grid)
+        else:
+            self.console.print(left)
+            self.console.print(right)
+
+    def _build_summary_panel(self, data: ReportData) -> Panel:
+        """Build the summary panel with license and dependency stats."""
+        table = Table(box=box.SIMPLE_HEAVY, expand=True, show_header=True)
         table.add_column("Metric", style="bold")
         table.add_column("Value", justify="right")
 
-        table.add_row("Total dependencies checked", str(data.total_dependencies))
-        table.add_row("[green]Packaged in Fedora[/green]", str(data.packaged_count))
-        table.add_row("[red]Missing from Fedora[/red]", str(data.missing_count))
+        # License row at the top if available
+        if data.root_license:
+            table.add_row("License", f"[magenta]{data.root_license}[/magenta]")
+
+        table.add_row("Total dependencies", str(data.total_dependencies))
+        table.add_row(
+            "[green]Packaged in Fedora[/green]", f"[green]{data.packaged_count}[/green]"
+        )
+        table.add_row(
+            "[red]Missing from Fedora[/red]", f"[red]{data.missing_count}[/red]"
+        )
 
-        # Show optional dependency stats if any were found
         if data.optional_total > 0:
-            table.add_row("", "")  # Empty row as separator
+            table.add_row("", "")
             table.add_row(
-                "[yellow]Optional dependencies[/yellow]", str(data.optional_total)
+                "[yellow]Optional dependencies[/yellow]",
+                str(data.optional_total),
+            )
+            table.add_row("[yellow]  Packaged[/yellow]", str(data.optional_packaged))
+            table.add_row("[yellow]  Missing[/yellow]", str(data.optional_missing))
+
+        if data.dev_total > 0:
+            table.add_row("", "")
+            table.add_row("[cyan]Dev dependencies[/cyan]", str(data.dev_total))
+            table.add_row("[cyan]  Packaged[/cyan]", str(data.dev_packaged))
+            table.add_row("[cyan]  Missing[/cyan]", str(data.dev_missing))
+
+        if data.build_total > 0:
+            table.add_row("", "")
+            table.add_row("[blue]Build dependencies[/blue]", str(data.build_total))
+            table.add_row("[blue]  Packaged[/blue]", str(data.build_packaged))
+            table.add_row("[blue]  Missing[/blue]", str(data.build_missing))
+
+        title = f"[bold]Summary for [cyan]{data.root_package}[/cyan] ({data.language})[/bold]"
+        return Panel(table, title=title, border_style="green", padding=(0, 1))
+
+    def _build_missing_required_panel(self, data: ReportData) -> Panel:
+        """Build the panel for missing required packages."""
+        required_missing = data.required_missing_packages
+        if required_missing:
+            table = Table(box=box.SIMPLE, expand=True, show_header=True)
+            table.add_column("Package", style="bold red")
+            for name in sorted(required_missing):
+                table.add_row(name)
+            content = table
+        else:
+            content = Text("None", style="dim")
+
+        return Panel(
+            content,
+            title="[bold red]Missing Required[/bold red]",
+            border_style="red",
+            padding=(0, 1),
+        )
+
+    def _build_missing_optional_panel(self, data: ReportData) -> Panel:
+        """Build the panel for missing optional packages."""
+        optional_missing = data.optional_missing_set
+        if optional_missing:
+            table = Table(box=box.SIMPLE, expand=True, show_header=True)
+            table.add_column("Package", style="bold yellow")
+            for name in sorted(optional_missing):
+                table.add_row(name)
+            content = table
+        else:
+            content = Text("None", style="dim")
+
+        return Panel(
+            content,
+            title="[bold yellow]Missing Optional[/bold yellow]",
+            border_style="yellow",
+            padding=(0, 1),
+        )
+
+    def _build_dep_panel(
+        self, deps: list[dict], title: str, border_style: str
+    ) -> Panel:
+        """Build a panel for dev or build dependencies."""
+        if deps:
+            table = Table(box=box.SIMPLE, expand=True, show_header=True)
+            table.add_column("", width=2)  # Status icon
+            table.add_column("Package", style="bold")
+            table.add_column("Version Req", style="dim")
+            table.add_column("Fedora", style="dim")
+            for dep in deps:
+                icon = "[green]✓[/green]" if dep["is_packaged"] else "[red]✗[/red]"
+                fedora_ver = ", ".join(dep.get("fedora_versions", [])) or "-"
+                table.add_row(icon, dep["name"], dep["version_requirement"], fedora_ver)
+            content = table
+        else:
+            content = Text("None", style="dim")
+
+        return Panel(content, title=title, border_style=border_style, padding=(0, 1))
+
+    def _build_features_panel(self, data: ReportData) -> Panel:
+        """Build the features / extras panel."""
+        table = Table(box=box.SIMPLE, expand=True, show_header=True)
+        table.add_column("Feature", style="bold magenta")
+        table.add_column("Dependencies")
+
+        for feature in data.features:
+            deps_str = (
+                ", ".join(feature.dependencies)
+                if hasattr(feature, "dependencies")
+                else ", ".join(feature.get("dependencies", []))
+            )
+            feature_name = (
+                feature.name if hasattr(feature, "name") else feature.get("name", "")
             )
-            table.add_row("[yellow]  ├─ Packaged[/yellow]", str(data.optional_packaged))
-            table.add_row("[yellow]  └─ Missing[/yellow]", str(data.optional_missing))
+            table.add_row(feature_name, deps_str or "[dim]-[/dim]")
+
+        return Panel(
+            table,
+            title="[bold magenta]Features / Extras[/bold magenta]",
+            border_style="magenta",
+            padding=(0, 1),
+        )
 
-        self.console.print(table)
-        self.console.print()
+    def generate(self, data: ReportData) -> str:
+        """Generate and print the report to stdout."""
+        # ── Summary (full width) ──
+        self.console.print(self._build_summary_panel(data))
 
-        # Print missing packages list using computed properties
+        # ── Missing packages: Required | Optional (side by side) ──
         if data.missing_packages:
-            required_missing = data.required_missing_packages
-            optional_missing = data.optional_missing_set
-
-            if required_missing:
-                self.console.print("[bold]Missing packages that need packaging:[/bold]")
-                for name in sorted(required_missing):
-                    self.console.print(f"  • {name}")
-                self.console.print()
-
-            if optional_missing:
-                self.console.print(
-                    "[bold yellow]Missing optional packages:[/bold yellow]"
+            left = self._build_missing_required_panel(data)
+            right = self._build_missing_optional_panel(data)
+            self._print_side_by_side(left, right)
+
+        # ── Dev | Build dependencies (side by side) ──
+        if data.dev_dependencies or data.build_dependencies:
+            left = self._build_dep_panel(
+                data.dev_dependencies,
+                "[bold cyan]Dev Dependencies[/bold cyan]",
+                "cyan",
+            )
+            right = self._build_dep_panel(
+                data.build_dependencies,
+                "[bold blue]Build Dependencies[/bold blue]",
+                "blue",
+            )
+            self._print_side_by_side(left, right)
+
+        # ── Features (full width) ──
+        if data.features:
+            self.console.print(self._build_features_panel(data))
+
+        # ── Dependency Tree (full width, skip if missing_only) ──
+        if not data.missing_only:
+            self.console.print(
+                Panel(
+                    data.tree,
+                    title="[bold]Dependency Tree[/bold]",
+                    border_style="dim",
+                    padding=(0, 1),
                 )
-                for name in sorted(optional_missing):
-                    self.console.print(f"  • {name} [dim](optional)[/dim]")
-                self.console.print()
-
-        # Print dependency tree
-        self.console.print("[bold]Dependency Tree:[/bold]")
-        self.console.print(data.tree)
-        self.console.print()
+            )
 
         return ""  # Output is printed directly