linman 0.0.1__py3-none-any.whl

apphub/cli/banner.py

@@ -0,0 +1,74 @@
+from rich.align import Align
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.text import Text
+
+# Block-style wordmark — reads clearly at typical terminal widths.
+_LOGO_LINES = [
+    r" ██╗     ██╗███╗   ██╗███╗   ███╗ █████╗ ███╗   ██╗",
+    r" ██║     ██║████╗  ██║████╗ ████║██╔══██╗████╗  ██║",
+    r" ██║     ██║██╔██╗ ██║██╔████╔██║███████║██╔██╗ ██║",
+    r" ██║     ██║██║╚██╗██║██║╚██╔╝██║██╔══██║██║╚██╗██║",
+    r" ███████╗██║██║ ╚████║██║ ╚═╝ ██║██║  ██║██║ ╚████║",
+    r" ╚══════╝╚═╝╚═╝  ╚═══╝╚═╝     ╚═╝╚═╝  ╚═╝╚═╝  ╚═══╝",
+]
+
+# Gradient stops (top → bottom) — cyan → blue → magenta.
+_GRADIENT = [
+    "bright_cyan",
+    "cyan",
+    "deep_sky_blue1",
+    "dodger_blue1",
+    "medium_purple",
+    "medium_orchid",
+]
+
+_TAGLINE = "Linux App Manager  ·  apt  ·  snap  ·  flatpak  ·  appimage"
+_SUB = "one CLI  ·  every format  ·  zero friction"
+
+
+def render_logo() -> Text:
+    """Return a colorized LINMAN wordmark."""
+    logo = Text()
+    for i, line in enumerate(_LOGO_LINES):
+        style = _GRADIENT[i % len(_GRADIENT)]
+        logo.append(line + "\n", style=f"bold {style}")
+    return logo
+
+
+def print_banner(
+    console: Console | None = None,
+    *,
+    version: str = "0.1.0",
+    show_panel: bool = True,
+) -> None:
+    """Print the linman logo banner to the terminal."""
+    console = console or Console()
+
+    logo = render_logo()
+    tagline = Text(_TAGLINE, style="bold white")
+    sub = Text(_SUB, style="dim italic")
+    ver = Text(f"v{version}", style="dim cyan")
+
+    body = Group(
+        Align.center(logo),
+        Align.center(tagline),
+        Align.center(sub),
+        Align.center(ver),
+    )
+
+    if show_panel:
+        console.print(
+            Panel(
+                body,
+                border_style="bright_cyan",
+                padding=(1, 2),
+                title="[bold bright_magenta]◆[/] [bold white]linman[/]",
+                title_align="left",
+                subtitle="[dim]unified package hub[/]",
+                subtitle_align="right",
+            )
+        )
+    else:
+        console.print(body)
+        console.print()

apphub/cli/commands.py

@@ -0,0 +1,276 @@
+import asyncio
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from apphub.cli.formatters import (
+    format_app_panel,
+    format_app_table,
+    format_history_table,
+    format_storage_table,
+)
+from apphub.cli.serializers import to_json, to_json_single
+from apphub.core.exceptions import AppNotFoundError
+from apphub.core.hub import AppHubCore
+from apphub.core.models import AppFormat, AppManifest, LifeCycleEvent
+
+cli_app = typer.Typer(no_args_is_help=True)
+hub = AppHubCore()
+console = Console()
+
+
+def _emit_app_list(
+    apps: list[AppManifest],
+    *,
+    title: str,
+    count: bool,
+    output_json: bool,
+) -> None:
+    if count:
+        console.print(f"[bold cyan]{len(apps)}[/bold cyan] application(s) found.")
+        return
+    if output_json:
+        console.print(to_json(apps))
+        return
+    console.print(format_app_table(apps, title=f"{title} ({len(apps)})"))
+
+
+def _prompt_select_app(
+    results: list[AppManifest], name: str, action: str
+) -> AppManifest:
+    if len(results) == 1:
+        return results[0]
+
+    console.print(f"[yellow]Found multiple applications matching '{name}':[/yellow]")
+    for idx, app in enumerate(results, start=1):
+        desc = app.description or "No description"
+        console.print(
+            f"[cyan][{idx}] | {app.name} ({app.format.value}) | {desc}[/cyan]"
+        )
+
+    choice: int = typer.prompt(f"Select an application to {action} (number)", type=int)
+    if choice < 1 or choice > len(results):
+        console.print("[red]Invalid selection.[/red]")
+        raise typer.Exit(1)
+    return results[choice - 1]
+
+
+@cli_app.command(name="list")
+def list_apps(
+    query: str | None = typer.Argument(None, help="Filter applications by name"),
+    formats: list[AppFormat] | None = typer.Option(
+        None, "--format", "-f", help="Filter by format"
+    ),
+    exclude_defaults: bool = typer.Option(
+        False, "--exclude-defaults", "-e", help="Exclude system/default packages"
+    ),
+    sort_by: str | None = typer.Option(
+        None, "--sort", "-s", help="Sort by field: name, version, format"
+    ),
+    count: bool = typer.Option(
+        False, "--count", "-n", help="Print only the number of matching apps"
+    ),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """List installed applications across all package managers."""
+    apps = asyncio.run(
+        hub.list_apps(query=query, formats=formats, exclude_defaults=exclude_defaults)
+    )
+
+    if sort_by:
+        apps = sorted(apps, key=lambda a: getattr(a, sort_by, "") or "")
+
+    _emit_app_list(apps, title="Applications", count=count, output_json=output_json)
+
+
+@cli_app.command(name="search")
+def search(
+    query: str = typer.Argument(..., help="Search applications by name or description"),
+    formats: list[AppFormat] | None = typer.Option(
+        None, "--format", "-f", help="Filter by format"
+    ),
+    count: bool = typer.Option(
+        False, "--count", "-n", help="Print only the number of matching apps"
+    ),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """Search available applications across supported registries."""
+    apps = asyncio.run(hub.search(query=query, formats=formats))
+    _emit_app_list(apps, title="Search Results", count=count, output_json=output_json)
+
+
+@cli_app.command(name="inspect")
+def inspect(
+    file_path: str = typer.Argument(
+        ..., help="Path to the application file or Application Name to be searched"
+    ),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """Inspect Local Installable File."""
+
+    if not Path(file_path).exists():
+        console.print(f"[red] No Application Found: '{file_path}'.[/red]")
+        raise typer.Exit(1)
+
+    app_info = asyncio.run(hub.inspect(path=file_path))
+
+    if output_json:
+        console.print(to_json_single(app_info))
+    else:
+        console.print(format_app_panel(app_info))
+
+
+@cli_app.command(name="install")
+def install(
+    path_or_name: str = typer.Argument(
+        ..., help="Path to the application file or Application Name"
+    ),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Auto confirm installation"),
+    launch: bool = typer.Option(
+        False, "--launch", "-l", help="Launch after installation"
+    ),
+    formats: list[AppFormat] | None = typer.Option(
+        None, "--format", "-f", help="Optional format lookup for application"
+    ),
+):
+    """Install an application (from registery or from file)."""
+
+    if Path(path_or_name).exists():
+        app_info = asyncio.run(hub.inspect(path=path_or_name))
+        console.print(format_app_panel(app_info))
+        install_target = path_or_name
+        install_format = app_info.format
+    else:
+        results = asyncio.run(hub.search(query=path_or_name, formats=formats))
+        if not results:
+            console.print(f"[red]No application found matching '{path_or_name}'.[/red]")
+            raise typer.Exit(1)
+
+        app_info = _prompt_select_app(results, path_or_name, "install")
+        if len(results) == 1:
+            console.print(f"Found this on {app_info.format.value}")
+        console.print(format_app_panel(app_info))
+        install_target = app_info.name
+        install_format = app_info.format
+
+    if not yes:
+        confirm = typer.confirm("Install this application?")
+        if not confirm:
+            print("Installation cancelled.")
+            raise typer.Exit()
+
+    result = asyncio.run(
+        hub.install(
+            query_or_path=install_target, install_format=install_format, launch=launch
+        )
+    )
+
+    if result:
+        console.print("[green]Installation successful[/green]")
+
+
+@cli_app.command(name="uninstall")
+def uninstall(
+    name: str = typer.Argument(..., help="Name of the application to uninstall"),
+    yes: bool = typer.Option(False, "--yes", "-y", help="Auto confirm installation"),
+    clean_uninstall: bool = typer.Option(
+        False,
+        "--clean",
+        "-c",
+        help="Clean Uninstall, remove data associated with application",
+    ),
+):
+    """Uninstall an installed application."""
+    results = asyncio.run(hub.list_apps(query=name))
+    if not results:
+        console.print(f"[red]No application found matching '{name}'.[/red]")
+        raise typer.Exit(1)
+
+    if len(results) == 1:
+        console.print(f"[bold yellow]Uninstalling {name}...[/bold yellow]")
+    app_info = _prompt_select_app(results, name, "uninstall")
+    console.print(format_app_panel(app_info))
+
+    if not yes:
+        confirm = typer.confirm("Uninstall this application?")
+        if not confirm:
+            print("Uninstallation cancelled.")
+            raise typer.Exit(1)
+
+    success = asyncio.run(hub.uninstall(app_info, clean_uninstall))
+    if success:
+        console.print(f"[green]Successfully uninstalled {name}.[/green]")
+    else:
+        console.print(
+            f"[red]Failed to uninstall {name} or application not found.[/red]"
+        )
+
+
+@cli_app.command(name="info")
+def info(
+    name: str = typer.Argument(..., help="Name of the application"),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """Show detailed information about an application."""
+    try:
+        app_info = asyncio.run(hub.info(query=name))
+    except AppNotFoundError:
+        console.print(f"[red]No application found matching '{name}'.[/red]")
+        raise typer.Exit(1)
+
+    if output_json:
+        console.print(to_json_single(app_info))
+        return
+    console.print(format_app_panel(app_info))
+
+
+@cli_app.command(name="storage")
+def storage(
+    formats: list[AppFormat] | None = typer.Option(
+        None, "--format", "-f", help="Filter by format"
+    ),
+    top: int | None = typer.Option(None, "--top", "-t", help="Show top N apps by size"),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+):
+    """Show disk usage by installed applications."""
+    apps = asyncio.run(hub.storage(formats=formats, top=top))
+
+    if output_json:
+        console.print(to_json(apps))
+        return
+
+    console.print(format_storage_table(apps, top=None))  # already sliced
+
+
+@cli_app.command(name="history")
+def history(
+    formats: list[AppFormat] | None = typer.Option(
+        None, "--format", "-f", help="Filter by format"
+    ),
+    action_categories: list[LifeCycleEvent] | None = typer.Option(
+        None, "--action-categories", "-a", help="Filter by action categories"
+    ),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+    order_by: str = typer.Option(
+        None, "--sort", "-s", help="Sort by field: name, version, timestamp"
+    ),
+    descending: bool = typer.Option(False, "--desc", "-d", help="Sort Descending"),
+    top: int = typer.Option(None, "--top", "-t", help="Show top N records"),
+):
+    """Show installation/uninstallation history."""
+    history_result = asyncio.run(
+        hub.history(formats=formats, action_categories=action_categories)
+    )
+
+    if order_by:
+        history_result.sort(key=lambda x: getattr(x, order_by, "") or "")
+    if descending:
+        history_result.reverse()
+    if top is not None:
+        history_result = history_result[:top]
+    if output_json:
+        console.print(to_json(history_result))
+        return
+
+    console.print(format_history_table(history_result))

apphub/cli/formatters.py

@@ -0,0 +1,136 @@
+from rich import box
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from apphub.core.models import AppManifest, AppRuntime, HistoryRecords, LifeCycleEvent
+
+console = Console()
+
+
+def _format_size(size_bytes: int | None) -> str:
+    if size_bytes is None:
+        return "—"
+    size = float(size_bytes)
+    for unit in ("B", "KB", "MB", "GB"):
+        if size < 1024:
+            return f"{size:.1f} {unit}"
+        size /= 1024
+
+    return f"{size:.1f} TB"
+
+
+def _styled_table(title: str) -> Table:
+    """Shared Rich table chrome for list/history views."""
+    return Table(
+        title=title,
+        box=box.ROUNDED,
+        highlight=True,
+        show_lines=False,
+        header_style="bold cyan",
+    )
+
+
+def format_app_table(apps: list[AppManifest], title: str = "Applications") -> Table:
+    """Styled Rich table for a list of AppManifest objects."""
+    table = _styled_table(title)
+    table.add_column("Name", style="bold white", min_width=20)
+    table.add_column("Format", style="yellow", justify="center")
+    table.add_column("Version", style="magenta")
+    table.add_column("Publisher", style="green")
+    table.add_column("Category", style="dim cyan")
+
+    for app in apps:
+        table.add_row(
+            app.name,
+            app.format.value,
+            app.version,
+            app.publisher or "—",
+            app.category or "—",
+        )
+    return table
+
+
+def format_app_panel(app: AppManifest) -> Panel:
+    """Rich Panel for `apphub info <name>`."""
+    lines = [
+        f"[bold]Name[/bold]:        {app.name}",
+        f"[bold]ID[/bold]:          {app.id}",
+        f"[bold]Format[/bold]:      {app.format.value}",
+        f"[bold]Version[/bold]:     {app.version}",
+        f"[bold]Publisher[/bold]:   {app.publisher or '—'}",
+        f"[bold]Category[/bold]:    {app.category or '—'}",
+        f"[bold]Installed[/bold]:   {'✓' if app.installed else '✗'}",
+        f"[bold]Size[/bold]:        {_format_size(app.size_bytes)}",
+    ]
+    if app.description:
+        lines.append(f"\n[bold]Description[/bold]:\n  {app.description}")
+
+    if app.icon:
+        lines.append(f"\n[bold]Icon[/bold]: {app.icon}")
+
+    if app.runtime != AppRuntime.NATIVE.value:
+        lines.append(f"\n[bold]Runtime[/bold]: {app.runtime.value}")
+
+    return Panel(
+        "\n".join(lines),
+        title=f"[bold cyan]{app.name}[/bold cyan]",
+        border_style="cyan",
+        padding=(1, 2),
+    )
+
+
+def format_storage_table(apps: list[AppManifest], top: int | None = None) -> Table:
+    """Storage breakdown table, sorted by size descending."""
+    sized = sorted(
+        [a for a in apps if a.size_bytes is not None],
+        key=lambda a: a.size_bytes or 0,
+        reverse=True,
+    )
+    unsized = [a for a in apps if a.size_bytes is None]
+    ordered = sized + unsized
+
+    if top is not None:
+        ordered = ordered[:top]
+
+    table = Table(
+        title="Storage Usage",
+        box=box.ROUNDED,
+        header_style="bold cyan",
+        show_lines=False,
+    )
+    table.add_column("Name", style="bold white", min_width=20)
+    table.add_column("Format", style="yellow", justify="center")
+    table.add_column("Size", style="magenta", justify="right")
+
+    for app in ordered:
+        table.add_row(app.name, app.format.value, _format_size(app.size_bytes))
+
+    return table
+
+
+def format_history_table(
+    history_records: list[HistoryRecords], title: str = "HistoryRecords"
+) -> Table:
+    """Styled Rich table for a list of HistoryRecords objects."""
+
+    table = _styled_table(title)
+    table.add_column("Name", style="bold white", min_width=20)
+    table.add_column("Format", style="yellow", justify="center")
+    table.add_column("Timestamp", style="magenta")
+    table.add_column("LifeCycle Event", style="red")
+    table.add_column("Version", style="green")
+
+    for record in history_records:
+        table.add_row(
+            record.app_name,
+            record.format.value,
+            record.timestamp.strftime("%B %d, %Y, %I:%M %p"),
+            record.lifecycle_event,
+            (
+                f"{record.old_version_id} -> {record.version_id}"
+                if record.lifecycle_event == LifeCycleEvent.UPGRADED
+                else record.version_id
+            ),
+        )
+    return table

apphub/cli/serializers.py

@@ -0,0 +1,14 @@
+import json
+
+from apphub.core.models import AppManifest, HistoryRecords
+
+
+def to_json(apps: list[AppManifest | HistoryRecords], indent: int = 2) -> str:
+    return json.dumps(
+        [app.model_dump(mode="json") for app in apps],
+        indent=indent,
+    )
+
+
+def to_json_single(app: AppManifest, indent: int = 2) -> str:
+    return json.dumps(app.model_dump(mode="json"), indent=indent)

apphub/core/exceptions.py

@@ -0,0 +1,52 @@
+class AppHubError(Exception):
+    """Base error for AppHub."""
+
+    pass
+
+
+class PluginError(AppHubError):
+    """Raised when Plugin need to raise exception"""
+
+    def __init__(self, plugin_name: str, msg: str):
+        super().__init__(msg)
+        self.plugin_name = plugin_name
+
+
+class PluginNotAvailableError(PluginError):
+    """Raised when a required backend (e.g. snap, flatpak) is not installed."""
+
+    def __init__(self, plugin_name: str):
+        super().__init__(
+            plugin_name=plugin_name,
+            msg=f"Plugin backend not available: '{plugin_name}'. Is it installed?",
+        )
+
+
+class AppNotFoundError(AppHubError):
+    """Raised when a requested application cannot be found."""
+
+    def __init__(self, app_name: str):
+        super().__init__(f"Application not found: '{app_name}'")
+        self.app_name = app_name
+
+
+class InstallError(AppHubError):
+    """Raised when an installation fails."""
+
+    def __init__(self, app_name: str, reason: str = ""):
+        msg = f"Failed to install '{app_name}'"
+        if reason:
+            msg += f": {reason}"
+        super().__init__(msg)
+        self.app_name = app_name
+
+
+class UninstallError(AppHubError):
+    """Raised when an uninstallation fails."""
+
+    def __init__(self, app_name: str, reason: str = ""):
+        msg = f"Failed to uninstall '{app_name}'"
+        if reason:
+            msg += f": {reason}"
+        super().__init__(msg)
+        self.app_name = app_name