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

woolly/languages/rust.py

@@ -0,0 +1,130 @@
+"""
+Rust/crates.io language provider.
+
+This provider fetches package information from crates.io and checks
+Fedora repositories for Rust crate packages.
+"""
+
+from typing import Optional
+
+from woolly import http
+from woolly.cache import DEFAULT_CACHE_TTL, read_cache, write_cache
+from woolly.debug import (
+    log_api_request,
+    log_api_response,
+    log_cache_hit,
+    log_cache_miss,
+)
+from woolly.languages.base import Dependency, LanguageProvider, PackageInfo
+
+CRATES_API = "https://crates.io/api/v1/crates"
+
+
+class RustProvider(LanguageProvider):
+    """Provider for Rust crates via crates.io."""
+
+    name = "rust"
+    display_name = "Rust"
+    registry_name = "crates.io"
+    fedora_provides_prefix = "crate"
+    cache_namespace = "crates"
+
+    def fetch_package_info(self, package_name: str) -> Optional[PackageInfo]:
+        """Fetch crate information from crates.io."""
+        cache_key = f"info:{package_name}"
+        cached = read_cache(self.cache_namespace, cache_key, DEFAULT_CACHE_TTL)
+        if cached is not None:
+            log_cache_hit(self.cache_namespace, cache_key)
+            if cached is False:  # Explicit "not found" cache
+                return None
+            return PackageInfo(
+                name=cached["crate"]["name"],
+                latest_version=cached["crate"]["newest_version"],
+                description=cached["crate"].get("description"),
+                homepage=cached["crate"].get("homepage"),
+                repository=cached["crate"].get("repository"),
+            )
+
+        log_cache_miss(self.cache_namespace, cache_key)
+        url = f"{CRATES_API}/{package_name}"
+        log_api_request("GET", url)
+        r = http.get(url)
+        log_api_response(r.status_code, r.text[:500] if r.text else None)
+
+        if r.status_code == 404:
+            write_cache(self.cache_namespace, cache_key, False)
+            return None
+        if r.status_code != 200:
+            raise RuntimeError(
+                f"Failed to fetch metadata for crate {package_name}: {r.status_code}"
+            )
+
+        data = r.json()
+        write_cache(self.cache_namespace, cache_key, data)
+
+        return PackageInfo(
+            name=data["crate"]["name"],
+            latest_version=data["crate"]["newest_version"],
+            description=data["crate"].get("description"),
+            homepage=data["crate"].get("homepage"),
+            repository=data["crate"].get("repository"),
+        )
+
+    def fetch_dependencies(self, package_name: str, version: str) -> list[Dependency]:
+        """Fetch dependencies for a specific crate version."""
+        cache_key = f"deps:{package_name}:{version}"
+        cached = read_cache(self.cache_namespace, cache_key, DEFAULT_CACHE_TTL)
+        if cached is not None:
+            log_cache_hit(self.cache_namespace, cache_key)
+            return [
+                Dependency(
+                    name=d["crate_id"],
+                    version_requirement=d["req"],
+                    optional=d.get("optional", False),
+                    kind=d.get("kind", "normal"),
+                )
+                for d in cached
+            ]
+
+        log_cache_miss(self.cache_namespace, cache_key)
+        url = f"{CRATES_API}/{package_name}/{version}/dependencies"
+        log_api_request("GET", url)
+        r = http.get(url)
+        log_api_response(r.status_code, r.text[:500] if r.text else None)
+
+        if r.status_code != 200:
+            write_cache(self.cache_namespace, cache_key, [])
+            return []
+
+        data = r.json()
+        deps = data.get("dependencies", [])
+        write_cache(self.cache_namespace, cache_key, deps)
+
+        return [
+            Dependency(
+                name=d["crate_id"],
+                version_requirement=d["req"],
+                optional=d.get("optional", False),
+                kind=d.get("kind", "normal"),
+            )
+            for d in deps
+        ]
+
+    def get_alternative_names(self, package_name: str) -> list[str]:
+        """
+        Get alternative names to try for crate lookup.
+
+        Rust crates can use either hyphens or underscores in names,
+        but they're treated as equivalent by Cargo.
+        """
+        alternatives = []
+
+        alt_underscore = package_name.replace("-", "_")
+        if alt_underscore != package_name:
+            alternatives.append(alt_underscore)
+
+        alt_hyphen = package_name.replace("_", "-")
+        if alt_hyphen != package_name:
+            alternatives.append(alt_hyphen)
+
+        return alternatives

woolly/progress.py

@@ -0,0 +1,69 @@
+"""
+Progress tracking utilities for dependency analysis.
+"""
+
+from rich.console import Console
+from rich.progress import (
+    BarColumn,
+    Progress,
+    SpinnerColumn,
+    TaskID,
+    TaskProgressColumn,
+    TextColumn,
+    TimeElapsedColumn,
+)
+
+
+class ProgressTracker:
+    """Tracks progress of dependency tree analysis."""
+
+    def __init__(self, console: Console):
+        self.console = console
+        self.progress = Progress(
+            SpinnerColumn(),
+            TextColumn("[bold blue]{task.description}"),
+            BarColumn(bar_width=30),
+            TaskProgressColumn(),
+            TextColumn("•"),
+            TimeElapsedColumn(),
+            TextColumn("[dim]{task.fields[status]}[/dim]"),
+            console=console,
+        )
+        self.task: TaskID = TaskID(0)
+        self.processed = 0
+        self.total_discovered = 0
+
+    def start(self, description: str = "Analyzing dependencies") -> None:
+        """Start the progress tracker."""
+        self.task = self.progress.add_task(
+            description, total=None, status="starting..."
+        )
+        self.progress.start()
+
+    def stop(self) -> None:
+        """Stop the progress tracker."""
+        self.progress.stop()
+
+    def update(self, package_name: str, discovered: int = 0) -> None:
+        """Update progress with current package being checked."""
+        self.processed += 1
+        self.total_discovered += discovered
+
+        if self.total_discovered > 0:
+            self.progress.update(
+                self.task,
+                completed=self.processed,
+                total=self.processed + self.total_discovered,
+                status=f"checking: {package_name}",
+            )
+        else:
+            self.progress.update(self.task, status=f"checking: {package_name}")
+
+    def finish(self) -> None:
+        """Mark progress as complete."""
+        self.progress.update(
+            self.task,
+            completed=self.processed,
+            total=self.processed,
+            status="[green]complete![/green]",
+        )

woolly/reporters/__init__.py

@@ -0,0 +1,111 @@
+"""
+Report generators registry.
+
+This module provides automatic discovery and registration of report generators.
+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 typing import Optional
+
+from pydantic import BaseModel, Field
+from rich.console import Console
+
+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
+
+
+class ReporterInfo(BaseModel):
+    """Information about an available reporter."""
+
+    format_id: str
+    description: str
+    aliases: list[str] = Field(default_factory=list)
+
+
+# Registry of available reporters
+# Key: format identifier (used in CLI)
+# Value: Reporter class
+REPORTERS: dict[str, type[Reporter]] = {
+    "stdout": StdoutReporter,
+    "markdown": MarkdownReporter,
+    "json": JsonReporter,
+}
+
+# Aliases for convenience
+ALIASES: dict[str, str] = {
+    "md": "markdown",
+    "console": "stdout",
+    "terminal": "stdout",
+}
+
+
+def get_reporter(
+    format_name: str, console: Optional[Console] = None
+) -> Optional[Reporter]:
+    """
+    Get an instantiated reporter for the specified format.
+
+    Args:
+        format_name: Format identifier or alias (e.g., "json", "markdown", "md")
+        console: Console instance for stdout reporter.
+
+    Returns:
+        Instantiated Reporter, or None if not found.
+    """
+    # Resolve aliases
+    format_name = format_name.lower()
+    if format_name in ALIASES:
+        format_name = ALIASES[format_name]
+
+    reporter_class = REPORTERS.get(format_name)
+    if reporter_class is None:
+        return None
+
+    # StdoutReporter needs a console
+    if format_name == "stdout" and console:
+        return StdoutReporter(console=console)
+
+    return reporter_class()
+
+
+def list_reporters() -> list[ReporterInfo]:
+    """
+    List all available reporters.
+
+    Returns:
+        List of ReporterInfo objects with format details.
+    """
+    result = []
+    for format_id, reporter_class in REPORTERS.items():
+        # Find aliases for this format
+        aliases = [alias for alias, target in ALIASES.items() if target == format_id]
+        result.append(
+            ReporterInfo(
+                format_id=format_id,
+                description=reporter_class.description,
+                aliases=aliases,
+            )
+        )
+    return result
+
+
+def get_available_formats() -> list[str]:
+    """Get list of available format identifiers."""
+    return list(REPORTERS.keys())
+
+
+__all__ = [
+    "Reporter",
+    "ReportData",
+    "ReporterInfo",
+    "StdoutReporter",
+    "MarkdownReporter",
+    "JsonReporter",
+    "get_reporter",
+    "list_reporters",
+    "get_available_formats",
+    "strip_markup",
+]

woolly/reporters/base.py

@@ -0,0 +1,213 @@
+"""
+Base abstract class defining the contract for report generators.
+
+To add support for a new report format, create a new module in the `reporters/` directory
+that implements a class inheriting from `Reporter`. The class must implement
+all abstract methods defined here.
+
+Example:
+    class HtmlReporter(Reporter):
+        name = "html"
+        description = "HTML report with interactive tree"
+        file_extension = "html"
+
+        def generate(self, data: ReportData) -> str:
+            # Generate HTML content
+            ...
+"""
+
+import re
+from abc import ABC, abstractmethod
+from datetime import datetime
+from functools import cached_property
+from pathlib import Path
+from typing import Any, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+def strip_markup(text: str) -> str:
+    """
+    Strip Rich markup from text.
+
+    Removes Rich markup tags like [bold], [/bold], [green], etc.
+
+    Args:
+        text: Text containing Rich markup.
+
+    Returns:
+        Plain text without markup.
+    """
+    return re.sub(r"\[/?[^\]]+\]", "", text)
+
+
+class ReportData(BaseModel):
+    """All data needed to generate a report."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    # Package info
+    root_package: str
+    language: str
+    registry: str
+
+    # Statistics
+    total_dependencies: int
+    packaged_count: int
+    missing_count: int
+    missing_packages: list[str] = Field(default_factory=list)
+    packaged_packages: list[str] = Field(default_factory=list)
+
+    # Optional dependency statistics
+    include_optional: bool = False
+    optional_total: int = 0
+    optional_packaged: int = 0
+    optional_missing: int = 0
+    optional_missing_packages: list[str] = Field(default_factory=list)
+
+    # Full tree for detailed reports
+    tree: Any  # Rich Tree object - not JSON serializable
+
+    # Metadata
+    timestamp: datetime = Field(default_factory=datetime.now)
+    max_depth: int = 50
+    version: Optional[str] = None
+
+    @cached_property
+    def required_missing_packages(self) -> set[str]:
+        """Get the set of required (non-optional) missing packages."""
+        return set(self.missing_packages) - set(self.optional_missing_packages)
+
+    @cached_property
+    def optional_missing_set(self) -> set[str]:
+        """Get the set of optional missing packages."""
+        return set(self.optional_missing_packages)
+
+    @cached_property
+    def unique_packaged_packages(self) -> set[str]:
+        """Get the unique set of packaged packages."""
+        return set(self.packaged_packages)
+
+
+class Reporter(ABC):
+    """
+    Abstract base class for report generators.
+
+    Each report format (stdout, markdown, json, etc.) must implement this interface.
+
+    Attributes:
+        name: Short identifier for the format (e.g., "json", "markdown")
+        description: Human-readable description
+        file_extension: File extension for output files (None for stdout)
+        writes_to_file: Whether this reporter writes to a file
+    """
+
+    # Class attributes that must be defined by subclasses
+    name: str
+    description: str
+    file_extension: Optional[str] = None
+    writes_to_file: bool = False
+
+    @abstractmethod
+    def generate(self, data: ReportData) -> str:
+        """
+        Generate the report content.
+
+        Args:
+            data: Report data containing all information.
+
+        Returns:
+            Report content as a string.
+        """
+        pass
+
+    def get_output_filename(self, data: ReportData) -> str:
+        """
+        Get the output filename for file-based reporters.
+
+        Args:
+            data: Report data.
+
+        Returns:
+            Filename string.
+        """
+        timestamp = data.timestamp.strftime("%Y%m%d_%H%M%S")
+        return f"woolly_{data.root_package}_{timestamp}.{self.file_extension}"
+
+    def write_report(
+        self, data: ReportData, output_dir: Optional[Path] = None
+    ) -> Optional[Path]:
+        """
+        Write the report to a file.
+
+        Args:
+            data: Report data.
+            output_dir: Directory to write to. Defaults to current directory.
+
+        Returns:
+            Path to the written file, or None for stdout reporters.
+        """
+        if not self.writes_to_file:
+            return None
+
+        content = self.generate(data)
+        output_dir = output_dir or Path.cwd()
+        output_path = output_dir / self.get_output_filename(data)
+        output_path.write_text(content)
+        return output_path
+
+    # ----------------------------------------------------------------
+    # Shared tree traversal utilities for subclasses
+    # ----------------------------------------------------------------
+
+    def _get_label(self, node) -> str:
+        """
+        Extract the label text from a tree node, handling nested Trees.
+
+        Args:
+            node: A Rich Tree node or string.
+
+        Returns:
+            The label text as a string.
+        """
+        # If it's a string, return it directly
+        if isinstance(node, str):
+            return node
+
+        # Try to get label attribute (Rich Tree has this)
+        if hasattr(node, "label"):
+            label = node.label
+            # If label is None, return empty string
+            if label is None:
+                return ""
+            # If label is another Tree-like object (has its own label), recurse
+            if hasattr(label, "label"):
+                return self._get_label(label)
+            # Otherwise convert to string
+            return str(label)
+
+        # Fallback - shouldn't happen
+        return str(node)
+
+    def _get_children(self, node) -> list:
+        """
+        Get all children from a tree node, flattening nested Trees.
+
+        Args:
+            node: A Rich Tree node.
+
+        Returns:
+            List of child nodes.
+        """
+        children = []
+
+        if hasattr(node, "children"):
+            for child in node.children:
+                # If the child's label is itself a Tree, use that Tree's children
+                if hasattr(child, "label") and hasattr(child.label, "children"):
+                    # The child is a wrapper around another tree
+                    children.append(child.label)
+                else:
+                    children.append(child)
+
+        return children

woolly/reporters/json.py

@@ -0,0 +1,175 @@
+"""
+JSON report generator.
+
+Generates a JSON file with structured data for machine consumption.
+"""
+
+import re
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+from woolly.reporters.base import ReportData, Reporter, strip_markup
+
+
+class TreeNodeData(BaseModel):
+    """Structured data for a single node in the dependency tree."""
+
+    raw: str
+    name: Optional[str] = None
+    version: Optional[str] = None
+    optional: bool = False
+    status: Optional[str] = None
+    is_packaged: Optional[bool] = None
+    fedora_versions: list[str] = Field(default_factory=list)
+    fedora_packages: list[str] = Field(default_factory=list)
+    dependencies: list["TreeNodeData"] = Field(default_factory=list)
+
+
+class ReportMetadata(BaseModel):
+    """Metadata for the JSON report."""
+
+    generated_at: str
+    tool: str = "woolly"
+    root_package: str
+    language: str
+    registry: str
+    version: Optional[str] = None
+    max_depth: int
+    include_optional: bool
+
+
+class ReportSummary(BaseModel):
+    """Summary statistics for the JSON report."""
+
+    total_dependencies: int
+    packaged_count: int
+    missing_count: int
+    optional: "OptionalSummary"
+
+
+class OptionalSummary(BaseModel):
+    """Optional dependency statistics."""
+
+    total: int
+    packaged: int
+    missing: int
+
+
+class JsonReport(BaseModel):
+    """Complete JSON report structure."""
+
+    metadata: ReportMetadata
+    summary: ReportSummary
+    missing_packages: list[str]
+    missing_optional_packages: list[str]
+    packaged_packages: list[str]
+    dependency_tree: TreeNodeData
+
+
+class JsonReporter(Reporter):
+    """Reporter that generates a JSON file."""
+
+    name = "json"
+    description = "JSON report file (machine-readable)"
+    file_extension = "json"
+    writes_to_file = True
+
+    def generate(self, data: ReportData) -> str:
+        """Generate JSON report content."""
+        report = JsonReport(
+            metadata=ReportMetadata(
+                generated_at=data.timestamp.isoformat(),
+                root_package=data.root_package,
+                language=data.language,
+                registry=data.registry,
+                version=data.version,
+                max_depth=data.max_depth,
+                include_optional=data.include_optional,
+            ),
+            summary=ReportSummary(
+                total_dependencies=data.total_dependencies,
+                packaged_count=data.packaged_count,
+                missing_count=data.missing_count,
+                optional=OptionalSummary(
+                    total=data.optional_total,
+                    packaged=data.optional_packaged,
+                    missing=data.optional_missing,
+                ),
+            ),
+            missing_packages=sorted(data.required_missing_packages),
+            missing_optional_packages=sorted(data.optional_missing_set),
+            packaged_packages=sorted(data.unique_packaged_packages),
+            dependency_tree=self._tree_to_model(data.tree),
+        )
+
+        return report.model_dump_json(indent=2)
+
+    def _tree_to_model(self, tree) -> TreeNodeData:
+        """Convert Rich Tree to TreeNodeData model."""
+        label = self._get_label(tree)
+        node_data = self._parse_label(label)
+
+        # Get children using inherited method
+        children = self._get_children(tree)
+
+        if children:
+            node_data.dependencies = [self._tree_to_model(child) for child in children]
+
+        return node_data
+
+    def _parse_label(self, label: str) -> TreeNodeData:
+        """Parse a tree label into structured TreeNodeData."""
+        # Strip Rich markup using shared utility
+        clean_label = strip_markup(label)
+
+        node = TreeNodeData(raw=clean_label.strip())
+
+        # Check if this is an optional dependency
+        node.optional = "(optional)" in clean_label
+
+        # Try to extract package name and version
+        # Pattern: "package_name vX.Y.Z (optional) • status" or "package_name vX.Y.Z • status"
+        match = re.match(
+            r"^(\S+)\s*(?:v([\d.]+))?\s*(?:\(optional\))?\s*•\s*(.+)$",
+            clean_label.strip(),
+        )
+        if match:
+            node.name = match.group(1)
+            if match.group(2):
+                node.version = match.group(2)
+
+            status_text = match.group(3).strip()
+            if (
+                "packaged" in status_text.lower()
+                and "not packaged" not in status_text.lower()
+            ):
+                node.status = "packaged"
+                # Try to extract Fedora versions
+                ver_match = re.search(r"\(([\d., ]+)\)", status_text)
+                if ver_match:
+                    node.fedora_versions = [
+                        v.strip() for v in ver_match.group(1).split(",")
+                    ]
+                # Try to extract package names
+                pkg_match = re.search(r"\[([^\]]+)\]", status_text)
+                if pkg_match:
+                    node.fedora_packages = [
+                        p.strip() for p in pkg_match.group(1).split(",")
+                    ]
+            elif "not packaged" in status_text.lower():
+                node.status = "not_packaged"
+            elif "not found" in status_text.lower():
+                node.status = "not_found"
+            elif "already visited" in status_text.lower():
+                node.status = "visited"
+                node.is_packaged = "✓" in status_text
+        else:
+            # Simpler patterns
+            if "already visited" in clean_label:
+                node.status = "visited"
+                node.is_packaged = "✓" in clean_label
+            elif "max depth" in clean_label:
+                node.status = "max_depth_reached"
+
+        return node