pkgwise 0.1.2__tar.gz → 0.2.0__tar.gz

{pkgwise-0.1.2 → pkgwise-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pkgwise
-Version: 0.1.2
+Version: 0.2.0
 Summary: Know what you're updating before you update — a smart Linux update analyzer.
 Author: PkgWise Developers
 License: MIT
@@ -21,6 +21,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: System :: Systems Administration
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -53,7 +54,7 @@ explicitly confirm the exact command.
 
 ## Features
 
-- **Dual package managers** — `pacman` (Arch) and `apt-get`/`apt-cache` (Debian, Kali, Ubuntu).
+- **Dual package managers** — `pacman` (Arch) and `apt-get`/`apt-cache` (Debian, Kali, Ubuntu), plus **Flatpak**, **Snap**, and a read-only **AUR** overlay (yay/paru) when installed. `check`/`updates` merge everything.
 - **Sizes you can plan with** — download and installed sizes are read from the package
   manager's own metadata, never guessed.
 - **Transparent priorities** — every CRITICAL/HIGH/MEDIUM/LOW label comes with the
@@ -63,6 +64,7 @@ explicitly confirm the exact command.
   checks gate every real update.
 - **Two interfaces** — a fast terminal CLI and a Textual TUI with selection, detail and
   confirmation screens.
+- **Upgrade history** — every check/update records a snapshot; compare runs with `pkgwise diff`.
 - **Mock mode** — preview the whole tool on any machine without touching a real package
   manager.
 
@@ -80,6 +82,11 @@ One command installs everything: the CLI, the TUI, and the storage analysis (psu
 $ pkgwise check                 # storage summary + available updates, prioritized
 $ pkgwise updates               # just the pending updates
 $ pkgwise storage               # disk information only (no package manager needed)
+$ pkgwise search <query>        # find packages across all detected backends
+$ pkgwise info <package>        # version/size/details of a single package
+$ pkgwise update <pkg…> --yes   # apply specific updates (commands shown first)
+$ pkgwise update --all --yes    # apply everything available
+$ pkgwise diff                  # what changed since the last check/update
 $ pkgwise --refresh             # refresh package indexes first (network)
 $ pkgwise                      # launch the interactive TUI
 $ pkgwise --version             # version and system info
@@ -115,8 +122,8 @@ reasons, so nothing is ever marked important without an explanation.
 | Nothing runs automatically | `cli.py`, TUI confirm screens |
 | Exact command shown before running | backends' `install_command()` |
 | Empty selection can't upgrade everything | backends return `[]` for empty selections |
-| Disk-space check before install | `analyzer.prepare_update()` |
-| Privilege check before install | `analyzer.prepare_update()` |
+| Disk-space check before install | `analyzer.plan_update()` |
+| Privilege check before install | `analyzer.plan_update()` |
 | No packages removed or cleaned | analyzer never invokes remove/clean |
 
 ## License

{pkgwise-0.1.2 → pkgwise-0.2.0}/README.md

@@ -18,7 +18,7 @@ explicitly confirm the exact command.
 
 ## Features
 
-- **Dual package managers** — `pacman` (Arch) and `apt-get`/`apt-cache` (Debian, Kali, Ubuntu).
+- **Dual package managers** — `pacman` (Arch) and `apt-get`/`apt-cache` (Debian, Kali, Ubuntu), plus **Flatpak**, **Snap**, and a read-only **AUR** overlay (yay/paru) when installed. `check`/`updates` merge everything.
 - **Sizes you can plan with** — download and installed sizes are read from the package
   manager's own metadata, never guessed.
 - **Transparent priorities** — every CRITICAL/HIGH/MEDIUM/LOW label comes with the
@@ -28,6 +28,7 @@ explicitly confirm the exact command.
   checks gate every real update.
 - **Two interfaces** — a fast terminal CLI and a Textual TUI with selection, detail and
   confirmation screens.
+- **Upgrade history** — every check/update records a snapshot; compare runs with `pkgwise diff`.
 - **Mock mode** — preview the whole tool on any machine without touching a real package
   manager.
 
@@ -45,6 +46,11 @@ One command installs everything: the CLI, the TUI, and the storage analysis (psu
 $ pkgwise check                 # storage summary + available updates, prioritized
 $ pkgwise updates               # just the pending updates
 $ pkgwise storage               # disk information only (no package manager needed)
+$ pkgwise search <query>        # find packages across all detected backends
+$ pkgwise info <package>        # version/size/details of a single package
+$ pkgwise update <pkg…> --yes   # apply specific updates (commands shown first)
+$ pkgwise update --all --yes    # apply everything available
+$ pkgwise diff                  # what changed since the last check/update
 $ pkgwise --refresh             # refresh package indexes first (network)
 $ pkgwise                      # launch the interactive TUI
 $ pkgwise --version             # version and system info
@@ -80,8 +86,8 @@ reasons, so nothing is ever marked important without an explanation.
 | Nothing runs automatically | `cli.py`, TUI confirm screens |
 | Exact command shown before running | backends' `install_command()` |
 | Empty selection can't upgrade everything | backends return `[]` for empty selections |
-| Disk-space check before install | `analyzer.prepare_update()` |
-| Privilege check before install | `analyzer.prepare_update()` |
+| Disk-space check before install | `analyzer.plan_update()` |
+| Privilege check before install | `analyzer.plan_update()` |
 | No packages removed or cleaned | analyzer never invokes remove/clean |
 
 ## License

{pkgwise-0.1.2 → pkgwise-0.2.0}/pkgwise/__init__.py

@@ -7,6 +7,6 @@ package manager (currently ``pacman`` and ``apt``) as its backend and provides
 a better interface for understanding and selecting package updates.
 """
 
-__version__ = "0.1.2"
+__version__ = "0.2.0"
 
 __all__ = ["__version__"]

{pkgwise-0.1.2 → pkgwise-0.2.0}/pkgwise/backends/arch.py

@@ -14,11 +14,13 @@ import re
 from typing import Dict, List, Optional
 
 from pkgwise.backends.base import InstallError, PackageManager
-from pkgwise.core.models import PackageUpdate
+from pkgwise.core.models import PackageInfo, PackageSearchResult, PackageUpdate
 from pkgwise.utils.commands import CommandError, run_command
 
 _QU_LINE = re.compile(r"^(?P<name>[^\s]+)\s+(?P<current>[^\s]+)\s*=>\s*(?P<new>[^\s]+)$")
 _SI_FIELD = re.compile(r"^(?P<key>[^:]+):(?P<value>.*)$")
+_SS_LINE = re.compile(r"^(?P<repo>[^/]+)/(?P<name>[^\s]+)\s+(?P<version>\S+)(?:\s+\[(?P<installed>[^\]]+)\])?$")
+_SS_DESC = re.compile(r"^\s+(?P<description>.+)$")
 
 _UPDATE_COMMAND = "-Su"
 
@@ -87,6 +89,19 @@ class ArchBackend(PackageManager):
             return []
         return ["pacman", "--noconfirm", _UPDATE_COMMAND, *selected]
 
+    def search_packages(self, query: str) -> List[PackageSearchResult]:
+        """Search sync databases via ``pacman -Ss`` (read-only, offline)."""
+        lines = self._run_pacman(["-Ss", query]).stdout.splitlines()
+        return _parse_syncdb_search(lines, manager=self.name)
+
+    def package_info(self, name: str) -> Optional[PackageInfo]:
+        """Read a package entry from the local sync databases (``pacman -Si``)."""
+        try:
+            output = self._run_pacman(["-Si", name]).stdout
+        except CommandError:
+            return None
+        return _parse_si_info(output, manager=self.name, fallback_name=name)
+
     # -- internal helpers --------------------------------------------------
 
     def _sync_databases(self) -> None:
@@ -140,6 +155,80 @@ def _parse_qu_line(line: str) -> Optional[tuple]:
     return (match.group("name"), match.group("current"), match.group("new"))
 
 
+def _parse_syncdb_search(lines: List[str], manager: str) -> List[PackageSearchResult]:
+    """Parse ``pacman -Ss`` output into ``PackageSearchResult`` items.
+
+    The sync-database format is a ``repo/name version`` pair line, optionally
+    marked ``[installed]``, immediately followed by an indented description.
+    """
+    results: List[PackageSearchResult] = []
+    pending: Optional[PackageSearchResult] = None
+    for raw in lines:
+        line = raw.rstrip()
+        pair = _SS_LINE.match(line)
+        if pair:
+            if pending is not None:
+                results.append(pending)
+            installed = pair.group("installed") is not None
+            repo = pair.group("repo")
+            pending = PackageSearchResult(
+                name=pair.group("name"),
+                version=pair.group("version"),
+                description="",
+                repository=repo,
+                installed=installed,
+                package_manager=manager,
+            )
+            continue
+        desc = _SS_DESC.match(line)
+        if desc and pending is not None and not pending.description:
+            pending = PackageSearchResult(
+                name=pending.name,
+                version=pending.version,
+                description=desc.group("description").strip(),
+                repository=pending.repository,
+                installed=pending.installed,
+                package_manager=manager,
+            )
+    if pending is not None:
+        results.append(pending)
+    return results
+
+
+def _parse_si_info(output: str, manager: str, fallback_name: str) -> Optional[PackageInfo]:
+    """Parse one ``pacman -Si`` stanza into a ``PackageInfo``."""
+    block: Dict[str, str] = {}
+    for raw in output.splitlines():
+        match = _SI_FIELD.match(raw.strip())
+        if not match:
+            continue
+        key = match.group("key").strip().lower()
+        block[key] = match.group("value").strip()
+
+    name = block.get("name") or fallback_name
+    depends = _split_depends(block.get("depends on"))
+    return PackageInfo(
+        name=name,
+        version=block.get("version"),
+        description=block.get("description"),
+        repository=block.get("repository", "").split("/")[0] or "",
+        license=block.get("licenses"),
+        architecture=block.get("architecture"),
+        homepage=block.get("url"),
+        depends=depends,
+        download_size=_parse_size(block.get("download size")),
+        installed_size=_parse_size(block.get("installed size")),
+        package_manager=manager,
+    )
+
+
+def _split_depends(raw: Optional[str]) -> List[str]:
+    """Parse ``Depends On`` into a list of package/symbol tokens."""
+    if not raw:
+        return []
+    return [part.strip() for part in raw.split() if part.strip()]
+
+
 def _parse_si_blocks(output: str) -> Dict[str, Dict[str, Optional[int]]]:
     """Parse consolidated ``pacman -Si`` output into ``{name: sizes}``.
 

pkgwise-0.2.0/pkgwise/backends/aur.py

@@ -0,0 +1,117 @@
+"""AUR backend — read-only overlay for Arch User Repository helpers.
+
+The AUR has no single binary: packages are managed by a *helper* such as
+``yay`` or ``paru``. This backend detects whichever helper is installed and
+uses it only for **read-only** operations (``-Qua``, ``-Ss``, ``-Si``).
+
+Deliberately, it does **not** install anything:
+
+- AUR packages are built from source by the helper (``makepkg``), so an
+  unattended update is out of scope for PkgWise's "show first, never default"
+  safety model;
+- :meth:`install_command` returns an empty list and
+  :meth:`install_updates` raises :class:`InstallError` explaining why.
+"""
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+from pkgwise.backends.arch import (
+    _parse_qu_line,
+    _parse_si_info,
+    _parse_syncdb_search,
+)
+from pkgwise.backends.base import InstallError, PackageManager
+from pkgwise.core.models import PackageInfo, PackageSearchResult, PackageUpdate
+from pkgwise.utils.commands import CommandError, run_command
+
+_HELPERS = ("yay", "paru")
+
+
+class AurBackend(PackageManager):
+    """AUR-helper-backed implementation (read-only overlay)."""
+
+    executable = ""
+    name = "aur"
+    needs_root = False
+
+    @property
+    def supported(self) -> bool:
+        return _detect_helper() is not None
+
+    def _helper(self) -> str:
+        helper = _detect_helper()
+        if helper is None:
+            raise InstallError(
+                "No AUR helper (yay or paru) is installed.",
+                detail="Install yay or paru to query AUR updates.",
+            )
+        self.executable = helper
+        return helper
+
+    # -- public API ---------------------------------------------------------
+
+    def check_updates(self) -> List[PackageUpdate]:
+        """List pending AUR updates via ``<helper> -Qua`` (read-only)."""
+        helper = self._helper()
+        output = run_command([helper, "-Qua"], timeout=120).stdout
+        updates: List[PackageUpdate] = []
+        for line in output.splitlines():
+            row = _parse_qu_line(line)
+            if row is None:
+                continue
+            name, current, new = row
+            updates.append(
+                PackageUpdate(
+                    name=name,
+                    current_version=current,
+                    new_version=new,
+                    package_manager=self.name,
+                )
+            )
+        return updates
+
+    def list_updates(self) -> List[PackageUpdate]:
+        """AUR helpers have no separate index refresh; check_updates == list."""
+        return self.check_updates()
+
+    def install_updates(self, names: List[str]) -> None:
+        """AUR helper installs are never triggered automatically by PkgWise."""
+        raise InstallError(
+            "PkgWise does not run AUR helper installs automatically.",
+            detail=(
+                "AUR packages are built from source. Review them with "
+                "'pkgwise search'/'pkgwise info' and install through yay/paru "
+                "yourself."
+            ),
+        )
+
+    def install_command(self, names: List[str]) -> List[str]:
+        """No deterministic install command is offered for AUR packages."""
+        return []
+
+    def search_packages(self, query: str) -> List[PackageSearchResult]:
+        """Search repos + AUR via ``<helper> -Ss``."""
+        helper = self._helper()
+        output = run_command([helper, "-Ss", query], timeout=120).stdout
+        return _parse_syncdb_search(output.splitlines(), manager=self.name)
+
+    def package_info(self, name: str) -> Optional[PackageInfo]:
+        """Read AUR metadata via ``<helper> -Si``; ``None`` when not found."""
+        helper = self._helper()
+        try:
+            output = run_command([helper, "-Si", name], timeout=60).stdout
+        except CommandError:
+            return None
+        return _parse_si_info(output, manager=self.name, fallback_name=name)
+
+
+def _detect_helper() -> Optional[str]:
+    """Return the installed AUR helper name, or ``None``."""
+    import shutil
+
+    for helper in _HELPERS:
+        if shutil.which(helper) is not None:
+            return helper
+    return None

{pkgwise-0.1.2 → pkgwise-0.2.0}/pkgwise/backends/base.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from typing import List, Optional
 
-from pkgwise.core.models import PackageUpdate
+from pkgwise.core.models import PackageInfo, PackageSearchResult, PackageUpdate
 
 
 class UpdateCheckError(Exception):
@@ -43,6 +43,10 @@ class PackageManager(ABC):
     #: Human name for the backend, e.g. "pacman".
     name: str = ""
 
+    #: Whether updates typically require root. Backends that manage per-user
+    #: state (e.g. flatpak) do not need the ``sudo`` elevation prefix.
+    needs_root: bool = True
+
     @property
     @abstractmethod
     def supported(self) -> bool:
@@ -71,6 +75,18 @@ class PackageManager(ABC):
         Exists so callers can display/confirm the exact command first.
         """
 
+    @abstractmethod
+    def search_packages(self, query: str) -> List[PackageSearchResult]:
+        """Search the package repositories for *query* (read-only)."""
+
+    @abstractmethod
+    def package_info(self, name: str) -> Optional[PackageInfo]:
+        """Return detailed metadata for a single package, or ``None``.
+
+        ``None`` means the backend could not find or inspect *name* — the CLI
+        renders that as "not found" rather than failing.
+        """
+
 
 class InstallError(Exception):
     """Raised when an update operation fails."""

{pkgwise-0.1.2 → pkgwise-0.2.0}/pkgwise/backends/debian.py

@@ -18,12 +18,13 @@ import re
 from typing import Dict, List, Optional, Tuple
 
 from pkgwise.backends.base import InstallError, PackageManager, UpdateCheckError
-from pkgwise.core.models import PackageUpdate
+from pkgwise.core.models import PackageInfo, PackageSearchResult, PackageUpdate
 from pkgwise.utils.commands import run_command
 
 _INST_LINE = re.compile(r"^Inst (?P<name>\S+)( \[(?P<current>[^\]]*)\])? \((?P<new>\S+)")
 _URI_LINE = re.compile(r"^'(?P<url>.*)'\s+(?P<filename>\S+)\s+(?P<size>\d+)")
 _STANZA_FIELD = re.compile(r"^(?P<key>[^:]+):\s*(?P<value>.*)$")
+_CACHE_SEARCH = re.compile(r"^(?P<name>\S+)\s*-\s*(?P<description>.*)$")
 
 _UPGRADE_TARGET = "upgrade"
 
@@ -89,6 +90,32 @@ class DebianBackend(PackageManager):
             return []
         return ["apt-get", "--yes", "install", *selected]
 
+    def search_packages(self, query: str) -> List[PackageSearchResult]:
+        """Search the apt package lists via ``apt-cache search`` (offline)."""
+        if _apt_cache_available() is False:
+            return []
+        result = run_command(["apt-cache", "search", query], timeout=180, check=False)
+        results: List[PackageSearchResult] = []
+        for line in result.stdout.splitlines():
+            match = _CACHE_SEARCH.match(line.strip())
+            if not match:
+                continue
+            results.append(
+                PackageSearchResult(
+                    name=match.group("name"),
+                    description=match.group("description").strip(),
+                    package_manager=self.name,
+                )
+            )
+        return results
+
+    def package_info(self, name: str) -> Optional[PackageInfo]:
+        """Read candidate metadata via ``apt-cache show`` for *name*."""
+        if _apt_cache_available() is False:
+            return None
+        result = run_command(["apt-cache", "show", name], timeout=180, check=False)
+        return _parse_apt_show_first(result.stdout, manager=self.name, fallback_name=name)
+
     # -- parsing helpers -----------------------------------------------------
 
     def _simulate_upgrade(self) -> List[PackageUpdate]:
@@ -217,6 +244,59 @@ def _parse_apt_cache_stanzas(output: str) -> List[Tuple[str, Optional[str], Opti
     return parsed
 
 
+def _apt_cache_available() -> bool:
+    """Return whether the ``apt-cache`` binary exists (import-local helper)."""
+    import shutil
+
+    return shutil.which("apt-cache") is not None
+
+
+def _parse_apt_show_first(output: str, manager: str, fallback_name: str) -> Optional[PackageInfo]:
+    """Parse the first ``apt-cache show`` stanza into a ``PackageInfo``."""
+    block: Dict[str, str] = {}
+    for raw in output.splitlines():
+        if raw.strip() == "":
+            if block:
+                break  # first stanza only
+            continue
+        match = _STANZA_FIELD.match(raw)
+        if not match:
+            continue
+        key = match.group("key").lower()
+        if key in {
+            "package", "version", "description", "architecture",
+            "homepage", "depends", "filename", "installed-size",
+        }:
+            block[key] = match.group("value").strip()
+
+    if "package" not in block and not output.strip():
+        return None
+
+    installed: Optional[int] = None
+    if block.get("installed-size"):
+        try:
+            installed = int(block["installed-size"]) * 1024
+        except ValueError:
+            installed = None
+
+    repo = ""
+    if block.get("filename"):
+        repo = block["filename"].split("/")[0]
+
+    return PackageInfo(
+        name=block.get("package") or fallback_name,
+        version=block.get("version"),
+        description=block.get("description"),
+        repository=repo,
+        architecture=block.get("architecture"),
+        homepage=block.get("homepage"),
+        depends=[p.strip() for p in (block.get("depends") or "").split(",") if p.strip()],
+        download_size=None,
+        installed_size=installed,
+        package_manager=manager,
+    )
+
+
 def _with_download_size(update: PackageUpdate, size: int) -> PackageUpdate:
     from dataclasses import replace
 

{pkgwise-0.1.2 → pkgwise-0.2.0}/pkgwise/backends/factory.py

@@ -7,11 +7,14 @@ analyzer. Selection is driven by the distro ID reported by os-release.
 
 from __future__ import annotations
 
-from typing import Dict
+from typing import Dict, List
 
 from pkgwise.backends.arch import ArchBackend
+from pkgwise.backends.aur import AurBackend
 from pkgwise.backends.base import PackageManager, UnsupportedDistroError
 from pkgwise.backends.debian import DebianBackend
+from pkgwise.backends.flatpak import FlatpakBackend
+from pkgwise.backends.snap import SnapBackend
 from pkgwise.utils import distro as distro_utils
 
 #: distro ID families -> backend class.
@@ -21,6 +24,11 @@ BACKENDS: Dict[str, type] = {
     # Future backends register here, e.g. "fedora": DnfBackend
 }
 
+#: Auxiliary backends that overlay the primary manager (flapkak/snap/AUR are
+#: independent of the OS package manager). Instantiated whenever their tool is
+#: available and merged into the same analysis result.
+AUX_BACKENDS: tuple = (FlatpakBackend, SnapBackend, AurBackend)
+
 
 def get_backend(distro_name: str = "", package_manager: str = "") -> PackageManager:
     """Return the backend matching the current system.
@@ -55,6 +63,42 @@ def get_backend(distro_name: str = "", package_manager: str = "") -> PackageMana
     )
 
 
+def get_aux_backends() -> List[PackageManager]:
+    """Return every auxiliary backend whose tool is installed (read-only check).
+
+    Errors are swallowed: a misbehaving overlay must never break the primary
+    analysis, and none of these run any side-effecting command during probing.
+    """
+    available: List[PackageManager] = []
+    for backend_cls in AUX_BACKENDS:
+        try:
+            instance = backend_cls()
+        except Exception:  # pragma: no cover - defensive
+            continue
+        try:
+            if instance.supported:
+                available.append(instance)
+        except Exception:  # pragma: no cover - defensive
+            continue
+    return available
+
+
+def get_all_backends() -> List[PackageManager]:
+    """Return the primary backend (if supported) plus all auxiliary backends.
+
+    Used by commands that operate across managers (``search``, ``update``).
+    The primary backend is attempted first so it stays first in the list, then
+    the auxiliaries in registration order.
+    """
+    backends: List[PackageManager] = []
+    try:
+        backends.append(get_backend())
+    except UnsupportedDistroError:  # pragma: no cover - exercised on exotic OSes
+        pass
+    backends.extend(get_aux_backends())
+    return backends
+
+
 def _managers_for(distro_key: str) -> tuple:
     """Map a backend key to the package-manager names it satisfies."""
     return {