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

woolly/commands/check.py

@@ -0,0 +1,422 @@
+"""
+Check command - analyze package dependencies for Fedora availability.
+"""
+
+from typing import Annotated, Optional
+
+import cyclopts
+from pydantic import BaseModel, Field
+from rich.tree import Tree
+
+from woolly.cache import CACHE_DIR
+from woolly.commands import app, console
+from woolly.debug import get_log_file, log, log_package_check, setup_logger
+from woolly.languages import get_available_languages, get_provider
+from woolly.languages.base import LanguageProvider
+from woolly.progress import ProgressTracker
+from woolly.reporters import ReportData, get_available_formats, get_reporter
+
+
+class TreeStats(BaseModel):
+    """Statistics collected from dependency tree analysis."""
+
+    total: int = 0
+    packaged: int = 0
+    missing: int = 0
+    missing_list: list[str] = Field(default_factory=list)
+    packaged_list: list[str] = Field(default_factory=list)
+    optional_total: int = 0
+    optional_packaged: int = 0
+    optional_missing: int = 0
+    optional_missing_list: list[str] = Field(default_factory=list)
+
+
+def build_tree(
+    provider: LanguageProvider,
+    package_name: str,
+    version: Optional[str] = None,
+    visited: Optional[dict] = None,
+    depth: int = 0,
+    max_depth: int = 50,
+    tracker: Optional[ProgressTracker] = None,
+    include_optional: bool = False,
+    is_optional_dep: bool = False,
+):
+    """
+    Recursively build a dependency tree for a package.
+
+    Parameters
+    ----------
+    provider
+        The language provider to use.
+    package_name
+        Name of the package to analyze.
+    version
+        Specific version, or None for latest.
+    visited
+        Dict of already-visited packages mapping to their status.
+    depth
+        Current recursion depth.
+    max_depth
+        Maximum recursion depth.
+    tracker
+        Optional progress tracker.
+    include_optional
+        If True, include optional dependencies in the analysis.
+    is_optional_dep
+        If True, this package is an optional dependency.
+
+    Returns
+    -------
+    Tree
+        Rich Tree object representing the dependency tree.
+    """
+    if visited is None:
+        visited = {}
+
+    optional_marker = " [yellow](optional)[/yellow]" if is_optional_dep else ""
+
+    if depth > max_depth:
+        log(f"Max depth reached for {package_name}", level="warning", depth=depth)
+        return f"[dim]{package_name}{optional_marker} (max depth reached)[/dim]"
+
+    if package_name in visited:
+        is_packaged, cached_version = visited[package_name]
+        log_package_check(
+            package_name,
+            "Skip (already visited)",
+            result="packaged" if is_packaged else "not packaged",
+        )
+        if is_packaged:
+            return f"[dim]{package_name}[/dim] [dim]v{cached_version}[/dim]{optional_marker} • [green]✓[/green] [dim](already visited)[/dim]"
+        else:
+            return f"[dim]{package_name}[/dim]{optional_marker} • [red]✗[/red] [dim](already visited)[/dim]"
+
+    if tracker:
+        tracker.update(package_name)
+
+    log_package_check(package_name, "Fetching version", source=provider.registry_name)
+
+    if version is None:
+        version = provider.get_latest_version(package_name)
+        if version is None:
+            visited[package_name] = (False, None)
+            log_package_check(
+                package_name, "Not found", source=provider.registry_name, result="error"
+            )
+            return (
+                f"[bold red]{package_name}[/bold red]{optional_marker} • "
+                f"[red]not found on {provider.registry_name}[/red]"
+            )
+
+    log_package_check(package_name, "Checking Fedora", source="dnf repoquery")
+
+    # Check Fedora packaging status
+    status = provider.check_fedora_packaging(package_name)
+    visited[package_name] = (status.is_packaged, version)
+
+    if status.is_packaged:
+        log_package_check(
+            package_name,
+            "Fedora status",
+            result=f"packaged ({', '.join(status.versions)})",
+        )
+    else:
+        log_package_check(package_name, "Fedora status", result="not packaged")
+
+    if status.is_packaged:
+        ver_str = ", ".join(status.versions) if status.versions else "unknown"
+        pkg_str = ", ".join(status.package_names) if status.package_names else ""
+        label = (
+            f"[bold]{package_name}[/bold] [dim]v{version}[/dim]{optional_marker} • "
+            f"[green]✓ packaged[/green] [dim]({ver_str})[/dim]"
+        )
+        if pkg_str:
+            label += f" [dim cyan][{pkg_str}][/dim cyan]"
+    else:
+        label = (
+            f"[bold]{package_name}[/bold] [dim]v{version}[/dim]{optional_marker} • "
+            f"[red]✗ not packaged[/red]"
+        )
+
+    node = Tree(label)
+
+    # ALWAYS recurse into dependencies regardless of packaging status
+    log_package_check(
+        package_name, "Fetching dependencies", source=provider.registry_name
+    )
+
+    deps = provider.get_normal_dependencies(
+        package_name, version, include_optional=include_optional
+    )
+
+    log(f"Found {len(deps)} dependencies for {package_name}", deps=len(deps))
+
+    if tracker and deps:
+        tracker.update(package_name, discovered=len(deps))
+
+    for dep_name, _dep_req, dep_is_optional in deps:
+        child = build_tree(
+            provider,
+            dep_name,
+            None,
+            visited,
+            depth + 1,
+            max_depth,
+            tracker,
+            include_optional=include_optional,
+            is_optional_dep=dep_is_optional,
+        )
+        if isinstance(child, str):
+            node.add(child)
+        elif isinstance(child, Tree):
+            # Directly append Tree children to avoid wrapping
+            # Rich's add() would wrap the Tree in another node
+            node.children.append(child)
+        else:
+            node.add(child)
+
+    return node
+
+
+def collect_stats(tree, stats: Optional[TreeStats] = None) -> TreeStats:
+    """Walk the tree and collect statistics."""
+    if stats is None:
+        stats = TreeStats()
+
+    def walk(t):
+        if isinstance(t, str):
+            stats.total += 1
+            is_optional = "(optional)" in t
+            if is_optional:
+                stats.optional_total += 1
+            if "not packaged" in t or "not found" in t:
+                stats.missing += 1
+                # Handle both [bold] and [bold red] formats
+                if "[/bold]" in t:
+                    name = t.split("[/bold]")[0].split("]")[-1]
+                elif "[/bold red]" in t:
+                    name = t.split("[/bold red]")[0].split("[bold red]")[-1]
+                else:
+                    name = t.split()[0]
+                stats.missing_list.append(name)
+                if is_optional:
+                    stats.optional_missing += 1
+                    stats.optional_missing_list.append(name)
+            elif "packaged" in t:
+                stats.packaged += 1
+                if is_optional:
+                    stats.optional_packaged += 1
+            return
+
+        if hasattr(t, "label"):
+            label = str(t.label)
+            stats.total += 1
+            is_optional = "(optional)" in label
+            if is_optional:
+                stats.optional_total += 1
+            if "not packaged" in label or "not found" in label:
+                stats.missing += 1
+                # Handle both [bold] and [bold red] formats
+                if "[bold]" in label and "[bold red]" not in label:
+                    name = label.split("[/bold]")[0].split("[bold]")[-1]
+                elif "[bold red]" in label:
+                    name = label.split("[/bold red]")[0].split("[bold red]")[-1]
+                else:
+                    name = "unknown"
+                stats.missing_list.append(name)
+                if is_optional:
+                    stats.optional_missing += 1
+                    stats.optional_missing_list.append(name)
+            elif "packaged" in label:
+                stats.packaged += 1
+                name = (
+                    label.split("[/bold]")[0].split("[bold]")[-1]
+                    if "[bold]" in label
+                    else "unknown"
+                )
+                stats.packaged_list.append(name)
+                if is_optional:
+                    stats.optional_packaged += 1
+
+        if hasattr(t, "children"):
+            for child in t.children:
+                walk(child)
+
+    walk(tree)
+    return stats
+
+
+@app.command(name="check")
+def check(
+    package: Annotated[
+        str,
+        cyclopts.Parameter(
+            help="Package name to check.",
+        ),
+    ],
+    *,
+    lang: Annotated[
+        str,
+        cyclopts.Parameter(
+            ("--lang", "-l"),
+            help="Language/ecosystem. Use 'list-languages' to see options.",
+        ),
+    ] = "rust",
+    version: Annotated[
+        Optional[str],
+        cyclopts.Parameter(
+            ("--version", "-v"),
+            help="Specific version to check.",
+        ),
+    ] = None,
+    max_depth: Annotated[
+        int,
+        cyclopts.Parameter(
+            ("--max-depth", "-d"),
+            help="Maximum recursion depth.",
+        ),
+    ] = 50,
+    optional: Annotated[
+        bool,
+        cyclopts.Parameter(
+            ("--optional", "-o"),
+            negative=(),
+            help="Include optional dependencies in the analysis.",
+        ),
+    ] = False,
+    no_progress: Annotated[
+        bool,
+        cyclopts.Parameter(
+            negative=(),
+            help="Disable progress bar.",
+        ),
+    ] = False,
+    debug: Annotated[
+        bool,
+        cyclopts.Parameter(
+            negative=(),
+            help="Enable verbose debug logging (includes command outputs and API responses).",
+        ),
+    ] = False,
+    report: Annotated[
+        str,
+        cyclopts.Parameter(
+            ("--report", "-r"),
+            help="Report format: stdout, json, markdown. Use 'list-formats' for all options.",
+        ),
+    ] = "stdout",
+):
+    """Check if a package's dependencies are available in Fedora.
+
+    Parameters
+    ----------
+    package
+        The name of the package to analyze.
+    lang
+        Language/ecosystem (default: rust).
+    version
+        Specific version to check (default: latest).
+    max_depth
+        Maximum recursion depth for dependency tree.
+    optional
+        Include optional dependencies in the analysis.
+    no_progress
+        Disable progress bar during analysis.
+    debug
+        Enable verbose debug logging.
+    report
+        Output format for the report.
+    """
+    # Get the language provider
+    provider = get_provider(lang)
+    if provider is None:
+        console.print(f"[red]Unknown language: {lang}[/red]")
+        console.print(f"Available languages: {', '.join(get_available_languages())}")
+        raise SystemExit(1)
+
+    # Get the reporter
+    reporter = get_reporter(report, console=console)
+    if reporter is None:
+        console.print(f"[red]Unknown report format: {report}[/red]")
+        console.print(f"Available formats: {', '.join(get_available_formats())}")
+        raise SystemExit(1)
+
+    # Initialize logging
+    setup_logger(debug=debug)
+    log(
+        "Analysis started",
+        package=package,
+        language=lang,
+        max_depth=max_depth,
+        include_optional=optional,
+        debug=debug,
+        report_format=report,
+    )
+
+    console.print(
+        f"\n[bold underline]Analyzing {provider.display_name} package:[/] {package}"
+    )
+    if optional:
+        console.print("[yellow]Including optional dependencies[/yellow]")
+    console.print(f"[dim]Registry: {provider.registry_name}[/dim]")
+    console.print(f"[dim]Cache directory: {CACHE_DIR}[/dim]")
+    console.print()
+
+    tracker = None if no_progress else ProgressTracker(console)
+
+    if tracker:
+        tracker.start(f"Analyzing {provider.display_name} dependencies")
+
+    try:
+        tree = build_tree(
+            provider,
+            package,
+            version,
+            max_depth=max_depth,
+            tracker=tracker,
+            include_optional=optional,
+        )
+        if tracker:
+            tracker.finish()
+    finally:
+        if tracker:
+            tracker.stop()
+        log("Analysis complete")
+
+    console.print()
+
+    # Collect statistics
+    stats = collect_stats(tree)
+
+    # Create report data
+    report_data = ReportData(
+        root_package=package,
+        language=provider.display_name,
+        registry=provider.registry_name,
+        total_dependencies=stats.total,
+        packaged_count=stats.packaged,
+        missing_count=stats.missing,
+        missing_packages=stats.missing_list,
+        packaged_packages=stats.packaged_list,
+        tree=tree,
+        max_depth=max_depth,
+        version=version,
+        include_optional=optional,
+        optional_total=stats.optional_total,
+        optional_packaged=stats.optional_packaged,
+        optional_missing=stats.optional_missing,
+        optional_missing_packages=stats.optional_missing_list,
+    )
+
+    # Generate report
+    if reporter.writes_to_file:
+        output_path = reporter.write_report(report_data)
+        console.print(f"[green]Report saved to: {output_path}[/green]")
+    else:
+        reporter.generate(report_data)
+
+    # Show log file path
+    log_file = get_log_file()
+    if log_file:
+        console.print(f"[dim]Log saved to: {log_file}[/dim]\n")

woolly/commands/clear_cache.py

@@ -0,0 +1,42 @@
+"""
+Clear cache command - clear cached data.
+"""
+
+from typing import Annotated
+
+import cyclopts
+
+from woolly.cache import clear_cache
+from woolly.commands import app, console
+
+
+@app.command(name="clear-cache")
+def clear_cache_cmd(
+    fedora_only: Annotated[
+        bool,
+        cyclopts.Parameter(
+            ("--fedora-only", "-f"),
+            negative=(),
+            help="Clear only Fedora repoquery cache.",
+        ),
+    ] = False,
+):
+    """Clear cached data.
+
+    Parameters
+    ----------
+    fedora_only
+        If set, only clear the Fedora repoquery cache.
+    """
+    if fedora_only:
+        cleared = clear_cache("fedora")
+        if cleared:
+            console.print("[yellow]Cleared Fedora cache[/yellow]")
+        else:
+            console.print("[yellow]No Fedora cache to clear[/yellow]")
+    else:
+        cleared = clear_cache()
+        if cleared:
+            console.print(f"[yellow]Cleared caches: {', '.join(cleared)}[/yellow]")
+        else:
+            console.print("[yellow]No cache to clear[/yellow]")

woolly/commands/list_formats.py

@@ -0,0 +1,24 @@
+"""
+List formats command - display available report formats.
+"""
+
+from rich import box
+from rich.table import Table
+
+from woolly.commands import app, console
+from woolly.reporters import list_reporters
+
+
+@app.command(name="list-formats")
+def list_formats_cmd():
+    """List available report formats."""
+    table = Table(title="Available Report Formats", box=box.ROUNDED)
+    table.add_column("Format", style="bold")
+    table.add_column("Description")
+    table.add_column("Aliases", style="dim")
+
+    for info in list_reporters():
+        alias_str = ", ".join(info.aliases) if info.aliases else "-"
+        table.add_row(info.format_id, info.description, alias_str)
+
+    console.print(table)

woolly/commands/list_languages.py

@@ -0,0 +1,26 @@
+"""
+List languages command - display available language providers.
+"""
+
+from rich import box
+from rich.table import Table
+
+from woolly.commands import app, console
+from woolly.languages import get_provider, list_providers
+
+
+@app.command(name="list-languages")
+def list_languages_cmd():
+    """List available language providers."""
+    table = Table(title="Available Languages", box=box.ROUNDED)
+    table.add_column("Language", style="bold")
+    table.add_column("Registry")
+    table.add_column("Aliases", style="dim")
+
+    for info in list_providers():
+        provider = get_provider(info.language_id)
+        registry = provider.registry_name if provider else "Unknown"
+        alias_str = ", ".join(info.aliases) if info.aliases else "-"
+        table.add_row(f"{info.display_name} ({info.language_id})", registry, alias_str)
+
+    console.print(table)

woolly/debug.py

@@ -0,0 +1,195 @@
+"""
+Logging utilities for woolly.
+
+All operations are logged to ~/.local/state/woolly/logs/
+- INFO level: Basic operation info (always logged)
+- DEBUG level: Detailed output from commands and API calls (with --debug)
+"""
+
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+# Log directory follows XDG Base Directory specification
+LOG_DIR = Path.home() / ".local" / "state" / "woolly" / "logs"
+
+# Global logger instance
+_logger: Optional[logging.Logger] = None
+_log_file: Optional[Path] = None
+_debug_enabled: bool = False
+
+
+def setup_logger(debug: bool = False) -> logging.Logger:
+    """
+    Set up the file logger.
+
+    Args:
+        debug: If True, log DEBUG level messages (command outputs, API responses).
+               If False, only log INFO level messages.
+
+    Returns:
+        Configured logger instance.
+    """
+    global _logger, _log_file, _debug_enabled
+
+    if _logger is not None:
+        return _logger
+
+    _debug_enabled = debug
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Create log file with timestamp
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    _log_file = LOG_DIR / f"woolly_{timestamp}.log"
+
+    _logger = logging.getLogger("woolly")
+    _logger.setLevel(logging.DEBUG)  # Logger accepts all, handler filters
+
+    # Clear any existing handlers
+    _logger.handlers.clear()
+
+    # File handler - level depends on debug flag
+    file_handler = logging.FileHandler(_log_file)
+    file_handler.setLevel(logging.DEBUG if debug else logging.INFO)
+    file_format = logging.Formatter(
+        "%(asctime)s | %(levelname)-8s | %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
+    )
+    file_handler.setFormatter(file_format)
+    _logger.addHandler(file_handler)
+
+    return _logger
+
+
+def is_debug_enabled() -> bool:
+    """Check if debug logging is enabled."""
+    return _debug_enabled
+
+
+def get_logger() -> logging.Logger:
+    """Get the global logger instance, creating it if needed."""
+    if _logger is None:
+        return setup_logger()
+    return _logger
+
+
+def get_log_file() -> Optional[Path]:
+    """Get the path to the current log file."""
+    return _log_file
+
+
+def log(message: str, level: str = "info", **kwargs) -> None:
+    """
+    Log a message to the file.
+
+    Args:
+        message: Message to log.
+        level: Log level (debug, info, warning, error).
+        **kwargs: Additional context to include.
+    """
+    logger = get_logger()
+
+    # Format context as key=value pairs
+    if kwargs:
+        context = " | " + " ".join(f"{k}={v}" for k, v in kwargs.items())
+        message = message + context
+
+    log_method = getattr(logger, level, logger.info)
+    log_method(message)
+
+
+def log_debug(message: str, **kwargs) -> None:
+    """Log a DEBUG level message (only shown with --debug)."""
+    log(message, level="debug", **kwargs)
+
+
+def log_info(message: str, **kwargs) -> None:
+    """Log an INFO level message (always shown)."""
+    log(message, level="info", **kwargs)
+
+
+def log_warning(message: str, **kwargs) -> None:
+    """Log a WARNING level message."""
+    log(message, level="warning", **kwargs)
+
+
+def log_error(message: str, **kwargs) -> None:
+    """Log an ERROR level message."""
+    log(message, level="error", **kwargs)
+
+
+def log_package_check(
+    package: str,
+    action: str,
+    source: Optional[str] = None,
+    result: Optional[str] = None,
+) -> None:
+    """
+    Log a package check operation (INFO level).
+
+    Args:
+        package: Package name being checked.
+        action: Action being performed.
+        source: Source of data (cache, api, repoquery).
+        result: Result of the operation.
+    """
+    log_info(
+        f"{action}: {package}",
+        package=package,
+        source=source,
+        result=result,
+    )
+
+
+def log_command_output(command: str, output: str, exit_code: int = 0) -> None:
+    """
+    Log command execution and output (DEBUG level).
+
+    Args:
+        command: The command that was executed.
+        output: The command output.
+        exit_code: The command exit code.
+    """
+    log_debug(f"Command: {command}")
+    log_debug(f"Exit code: {exit_code}")
+    if output:
+        for line in output.strip().split("\n"):
+            log_debug(f"  > {line}")
+
+
+def log_api_request(method: str, url: str) -> None:
+    """
+    Log an API request (DEBUG level).
+
+    Args:
+        method: HTTP method (GET, POST, etc.)
+        url: The URL being requested.
+    """
+    log_debug(f"API {method}: {url}")
+
+
+def log_api_response(status_code: int, body: Optional[str] = None) -> None:
+    """
+    Log an API response (DEBUG level).
+
+    Args:
+        status_code: HTTP status code.
+        body: Response body (truncated if too long).
+    """
+    log_debug(f"Response: {status_code}")
+    if body and is_debug_enabled():
+        # Truncate very long responses
+        if len(body) > 500:
+            body = body[:500] + "... (truncated)"
+        for line in body.strip().split("\n")[:10]:  # Max 10 lines
+            log_debug(f"  > {line}")
+
+
+def log_cache_hit(namespace: str, key: str) -> None:
+    """Log a cache hit (DEBUG level)."""
+    log_debug(f"Cache HIT: {namespace}/{key}")
+
+
+def log_cache_miss(namespace: str, key: str) -> None:
+    """Log a cache miss (DEBUG level)."""
+    log_debug(f"Cache MISS: {namespace}/{key}")