pkgwho 0.1.1__py3-none-any.whl

pkgwho/__about__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: 2026-present Toshihiro Kamiya <kamiya@mbj.nifty.com>
+#
+# SPDX-License-Identifier: MIT
+__version__ = "0.1.1"

pkgwho/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2026-present Toshihiro Kamiya <kamiya@mbj.nifty.com>
+#
+# SPDX-License-Identifier: MIT

pkgwho/cli.py

@@ -0,0 +1,808 @@
+# SPDX-FileCopyrightText: 2026-present Toshihiro Kamiya <kamiya@mbj.nifty.com>
+#
+# SPDX-License-Identifier: MIT
+"""Command line interface for identifying package ownership."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shlex
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass, field
+from functools import lru_cache
+from pathlib import Path
+from typing import Any, Sequence
+
+from pkgwho.__about__ import __version__
+from pkgwho.shell_config import PathSetup, find_path_setup
+
+
+@dataclass
+class Result:
+    command: str
+    executable: str | None
+    realpath: str | None
+    manager: str
+    package: str | None = None
+    uninstall: str | None = None
+    note: str | None = None
+    matches: list[PackageMatch] = field(default_factory=list)
+    path_setup: list[PathSetup] = field(default_factory=list)
+
+
+@dataclass
+class PackageMatch:
+    manager: str
+    package: str
+    uninstall: str
+    display_name: str | None = None
+    evidence: str = "name match"
+    section: str | None = None
+
+
+@dataclass
+class FontMatch:
+    family: str
+    style: str
+    fullname: str
+    file: str
+    packages: list[PackageMatch] = field(default_factory=list)
+
+
+def search_fonts(query: str) -> list[FontMatch] | None:
+    """Find installed Fontconfig faces and identify their file owners."""
+    output = _run(["fc-list", "--format", "%{family}\t%{style}\t%{fullname}\t%{file}\n"])
+    if output is None:
+        return None
+    needle = _normalize_name(query)
+    matches = []
+    owners: dict[str, list[PackageMatch]] = {}
+    seen: set[tuple[str, str, str, str]] = set()
+    for line in output.splitlines():
+        fields = line.split("\t", 3)
+        if len(fields) != 4 or not fields[3]:
+            continue
+        family, style, fullname, filename = fields
+        if not any(needle in _normalize_name(name) for name in (family, fullname)):
+            continue
+        key = (family, style, fullname, filename)
+        if key in seen:
+            continue
+        seen.add(key)
+        if filename not in owners:
+            path = Path(filename)
+            try:
+                realpath = path.resolve(strict=True)
+            except OSError:
+                realpath = path
+            paths = (path,) if path == realpath else (path, realpath)
+            packages = []
+            package = _dpkg_owner(paths)
+            if package:
+                packages.append(PackageMatch("dpkg", package, "sudo apt remove " + shlex.quote(package), evidence="dpkg path record"))
+            package = _brew_owner(paths)
+            if package:
+                packages.append(PackageMatch("brew", package, "brew uninstall " + shlex.quote(package), evidence="Homebrew file record"))
+            owners[filename] = packages
+        matches.append(FontMatch(family, style, fullname, filename, owners[filename]))
+    return sorted(matches, key=lambda item: (item.family.casefold(), item.style.casefold(), item.file))
+
+
+def _font_result(query: str, matches: list[FontMatch] | None) -> dict[str, object]:
+    return {
+        "font": query,
+        "note": "Fontconfig fc-list is unavailable" if matches is None else ("no installed font matched" if not matches else None),
+        "matches": [
+            {"family": m.family, "style": m.style, "fullname": m.fullname, "file": m.file,
+             "packages": [{"manager": p.manager, "package": p.package, "uninstall": p.uninstall, "evidence": p.evidence} for p in m.packages]}
+            for m in matches or []
+        ],
+    }
+
+
+def _format_fonts(query: str, matches: list[FontMatch] | None, no_limit: bool) -> str:
+    lines = [query]
+    if matches is None:
+        lines.append("  note:       Fontconfig fc-list is unavailable")
+    elif not matches:
+        lines.append("  note:       no installed font matched")
+    else:
+        for match in matches if no_limit else matches[:20]:
+            lines.append("  font:       " + (match.fullname or match.family))
+            lines.append("    family:   " + match.family)
+            lines.append("    style:    " + match.style)
+            lines.append("    file:     " + match.file)
+            if match.packages:
+                lines.extend(_format_matches(match.packages, True, path_records=True))
+            else:
+                lines.append("    package:  unknown")
+        if not no_limit and len(matches) > 20:
+            lines.append("  ... {} more matches; use --no-limit to display all matches".format(len(matches) - 20))
+    return "\n".join(lines)
+
+
+def _run(args: Sequence[str]) -> str | None:
+    """Run a package-manager query without invoking a shell."""
+    try:
+        result = subprocess.run(
+            args,
+            check=False,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            timeout=10,
+        )
+    except (FileNotFoundError, OSError, subprocess.TimeoutExpired):
+        return None
+    if result.returncode != 0:
+        return None
+    return result.stdout.strip()
+
+
+def _resolve(command: str) -> Path | None:
+    """Resolve a command name or an explicitly supplied path."""
+    expanded = Path(os.path.expandvars(os.path.expanduser(command)))
+    if expanded.is_absolute() or "/" in command:
+        if expanded.exists() and expanded.is_file():
+            return expanded.absolute()
+        return None
+    found = shutil.which(command)
+    return Path(found).absolute() if found else None
+
+
+def _dpkg_owner(paths: Sequence[Path]) -> str | None:
+    for path in paths:
+        output = _run(["dpkg-query", "-S", str(path)])
+        if not output:
+            continue
+        for line in output.splitlines():
+            # dpkg-query emits one "package: path" record per owner.
+            package, separator, owned_path = line.partition(": ")
+            if separator and owned_path == str(path):
+                return package[:-4] if package.endswith(":any") else package
+    return None
+
+
+@lru_cache(maxsize=1)
+def _snap_packages() -> set[str]:
+    output = _run(["snap", "list"])
+    if not output:
+        return set()
+    rows = output.splitlines()[1:]
+    return {row.split()[0] for row in rows if row.split()}
+
+
+def _snap_owner(executable: Path) -> str | None:
+    # Snap command aliases live in /snap/bin even when their target resolves
+    # to /usr/bin/snap, so inspect the original path before its realpath.
+    if executable.parent != Path("/snap/bin"):
+        return None
+    candidate = executable.name
+    packages = _snap_packages()
+    if candidate in packages:
+        return candidate
+    # Additional applications from a snap are exposed as <snap>.<app>.
+    matches = [name for name in packages if candidate.startswith(name + ".")]
+    return max(matches, key=len) if matches else None
+
+
+@lru_cache(maxsize=1)
+def _flatpak_apps() -> set[str]:
+    output = _run(["flatpak", "list", "--app", "--columns=application"])
+    return set(output.splitlines()) if output else set()
+
+
+@lru_cache(maxsize=1)
+def _pipx_tools() -> list[tuple[str, set[str]]]:
+    output = _run(["pipx", "list", "--output", "json"])
+    if not output:
+        return []
+    try:
+        data = json.loads(output)
+    except json.JSONDecodeError:
+        return []
+
+    tools: list[tuple[str, set[str]]] = []
+    venvs = data.get("venvs", {})
+    if not isinstance(venvs, dict):
+        return tools
+    for environment, record in venvs.items():
+        if not isinstance(record, dict):
+            continue
+        metadata = record.get("metadata", record)
+        if not isinstance(metadata, dict):
+            continue
+        main_package = metadata.get("main_package", {})
+        if not isinstance(main_package, dict):
+            continue
+        package = main_package.get("package") or environment
+        apps = set()
+        for app in main_package.get("apps", []):
+            if isinstance(app, str):
+                apps.add(Path(app).name)
+        dependency_apps = main_package.get("apps_of_dependencies", {})
+        if isinstance(dependency_apps, dict):
+            for app_list in dependency_apps.values():
+                if isinstance(app_list, list):
+                    apps.update(Path(app).name for app in app_list if isinstance(app, str))
+        tools.append((str(package), apps))
+    return tools
+
+
+@lru_cache(maxsize=1)
+def _uv_tools() -> list[tuple[str, set[str]]]:
+    output = _run(["uv", "tool", "list", "--show-paths"])
+    if not output:
+        return []
+
+    tools: list[tuple[str, set[str]]] = []
+    current_package: str | None = None
+    current_apps: set[str] = set()
+    for line in output.splitlines():
+        header = re.match(r"^(\S+)\s+v\S+", line)
+        if header:
+            if current_package is not None:
+                tools.append((current_package, current_apps))
+            current_package = header.group(1)
+            current_apps = set()
+            continue
+        app = re.match(r"^\s+-\s+(\S+)\s*$", line)
+        if app and "/" not in app.group(1):
+            current_apps.add(Path(app.group(1)).name)
+    if current_package is not None:
+        tools.append((current_package, current_apps))
+    return tools
+
+
+@lru_cache(maxsize=1)
+def _cargo_tools() -> list[tuple[str, set[str]]]:
+    output = _run(["cargo", "install", "--list"])
+    if not output:
+        return []
+
+    tools: list[tuple[str, set[str]]] = []
+    current_package: str | None = None
+    current_bins: set[str] = set()
+    for line in output.splitlines():
+        header = re.match(r"^(.+?)\s+v[^\s:]+:", line)
+        if header:
+            if current_package is not None:
+                tools.append((current_package, current_bins))
+            current_package = header.group(1)
+            current_bins = set()
+            continue
+        binary = re.match(r"^\s+([^\s]+)\s*$", line)
+        if binary:
+            current_bins.add(binary.group(1))
+    if current_package is not None:
+        tools.append((current_package, current_bins))
+    return tools
+
+
+@lru_cache(maxsize=1)
+def _brew_packages() -> list[tuple[str, str]]:
+    packages: list[tuple[str, str]] = []
+    for kind, args in (
+        ("formula", ["brew", "list", "--formula"]),
+        ("cask", ["brew", "list", "--cask"]),
+    ):
+        output = _run(args)
+        if output:
+            packages.extend((kind, line.strip()) for line in output.splitlines() if line.strip())
+    return packages
+
+
+@lru_cache(maxsize=1)
+def _brew_owner(paths: tuple[Path, ...]) -> str | None:
+    output = _run(["brew", "list", "--formula", "--verbose"])
+    if not output:
+        return None
+    expected = {path.resolve() for path in paths}
+    for line in output.splitlines():
+        candidate = Path(line.strip())
+        if not candidate.is_absolute():
+            continue
+        try:
+            if candidate.resolve() in expected:
+                parts = candidate.parts
+                if "Cellar" in parts:
+                    index = parts.index("Cellar")
+                    if index + 1 < len(parts):
+                        return parts[index + 1]
+        except OSError:
+            continue
+    return None
+
+
+def _pipx_owner(executable: Path, realpath: Path) -> str | None:
+    expected_root = Path(
+        os.environ.get("PIPX_HOME", Path.home() / ".local/share/pipx")
+    ).expanduser()
+    try:
+        is_pipx_path = realpath.is_relative_to(expected_root)
+    except (OSError, ValueError):
+        is_pipx_path = False
+    if not is_pipx_path:
+        return None
+    for package, apps in _pipx_tools():
+        if executable.name in apps:
+            return package
+    return None
+
+
+def _uv_owner(executable: Path, realpath: Path) -> str | None:
+    expected_root = Path(
+        os.environ.get("UV_TOOL_DIR", Path.home() / ".local/share/uv/tools")
+    ).expanduser()
+    try:
+        is_uv_path = realpath.is_relative_to(expected_root)
+    except (OSError, ValueError):
+        is_uv_path = False
+    if not is_uv_path:
+        return None
+    for package, apps in _uv_tools():
+        if executable.name in apps:
+            return package
+    return None
+
+
+def _cargo_owner(executable: Path, realpath: Path) -> str | None:
+    cargo_home = Path(os.environ.get("CARGO_HOME", Path.home() / ".cargo")).expanduser()
+    try:
+        is_cargo_path = executable.is_relative_to(cargo_home / "bin") or realpath.is_relative_to(
+            cargo_home / "bin"
+        )
+    except (OSError, ValueError):
+        is_cargo_path = False
+    if not is_cargo_path:
+        return None
+    for package, binaries in _cargo_tools():
+        if executable.name in binaries:
+            return package
+    return None
+
+
+def _search_installed_packages(query: str) -> list[PackageMatch]:
+    """Find installed packages whose identifier or display name contains query."""
+    needle = _normalize_name(query)
+    matches: list[PackageMatch] = []
+
+    output = _run(
+        ["dpkg-query", "-W", "-f=${binary:Package}\t${Version}\t${Section}\n"]
+    )
+    if output:
+        for line in output.splitlines():
+            fields = line.split("\t", 2)
+            if len(fields) >= 2 and needle in _normalize_name(fields[0]):
+                package = fields[0]
+                section = fields[2].strip() if len(fields) > 2 else ""
+                matches.append(
+                    PackageMatch(
+                        "dpkg",
+                        package,
+                        "sudo apt remove " + shlex.quote(package),
+                        section=section or None,
+                    )
+                )
+
+    for package in sorted(_snap_packages()):
+        if needle in _normalize_name(package):
+            matches.append(
+                PackageMatch(
+                    "snap",
+                    package,
+                    "sudo snap remove " + shlex.quote(package),
+                )
+            )
+
+    flatpak_output = _run(
+        ["flatpak", "list", "--app", "--columns=application,name"]
+    )
+    if flatpak_output:
+        for line in flatpak_output.splitlines():
+            fields = line.split("\t", 1)
+            if len(fields) == 1:
+                fields = line.split(None, 1)
+            app_id = fields[0].strip()
+            display_name = fields[1].strip() if len(fields) > 1 else ""
+            if needle in _normalize_name(app_id) or needle in _normalize_name(display_name):
+                matches.append(
+                    PackageMatch(
+                        "flatpak",
+                        app_id,
+                        "flatpak uninstall " + shlex.quote(app_id),
+                        display_name or None,
+                    )
+                )
+
+    for manager, tools, uninstall_prefix in (
+        ("pipx", _pipx_tools(), "pipx uninstall "),
+        ("uv", _uv_tools(), "uv tool uninstall "),
+        ("cargo", _cargo_tools(), "cargo uninstall "),
+    ):
+        for package, commands in tools:
+            matching_command = next(
+                (name for name in sorted(commands) if needle in _normalize_name(name)),
+                None,
+            )
+            if needle in _normalize_name(package) or matching_command:
+                matches.append(
+                    PackageMatch(
+                        manager,
+                        package,
+                        uninstall_prefix + shlex.quote(package),
+                        display_name=matching_command,
+                    )
+                )
+
+    for kind, package in _brew_packages():
+        if needle in _normalize_name(package):
+            uninstall = "brew uninstall "
+            if kind == "cask":
+                uninstall += "--cask "
+            matches.append(
+                PackageMatch(
+                    "brew",
+                    package,
+                    uninstall + shlex.quote(package),
+                )
+            )
+
+    return matches
+
+
+def _normalize_name(value: str) -> str:
+    """Normalize package names for case- and punctuation-insensitive matching."""
+    return "".join(character for character in value.casefold() if character.isalnum())
+
+
+def _flatpak_owner(executable: Path) -> str | None:
+    # Flatpak exports launchers under exports/bin/<application-id>. A normal
+    # command provided inside an app is not exposed on the host PATH.
+    parts = executable.parts
+    try:
+        marker = parts.index("exports")
+    except ValueError:
+        return None
+    if marker + 2 >= len(parts) or parts[marker + 1] != "bin":
+        return None
+    candidate = executable.name
+    return candidate if candidate in _flatpak_apps() else None
+
+
+def inspect(command: str) -> Result:
+    executable = _resolve(command)
+    if executable is None:
+        return Result(command, None, None, "unknown", note="command not found")
+
+    try:
+        realpath = executable.resolve(strict=True)
+    except OSError:
+        realpath = executable
+
+    is_manager_launcher = executable.parent == Path("/snap/bin") or (
+        "exports" in executable.parts and "bin" in executable.parts
+    )
+    paths = (
+        (executable,)
+        if is_manager_launcher or executable == realpath
+        else (executable, realpath)
+    )
+
+    direct_matches: list[PackageMatch] = []
+    package = _dpkg_owner(paths)
+    if package:
+        direct_matches.append(
+            PackageMatch(
+                "dpkg",
+                package,
+                "sudo apt remove " + shlex.quote(package),
+                evidence="dpkg path record",
+            )
+        )
+
+    package = _snap_owner(executable)
+    if package:
+        direct_matches.append(
+            PackageMatch(
+                "snap",
+                package,
+                "sudo snap remove " + shlex.quote(package),
+                evidence="snap command path",
+            )
+        )
+
+    package = _flatpak_owner(executable)
+    if package:
+        direct_matches.append(
+            PackageMatch(
+                "flatpak",
+                package,
+                "flatpak uninstall " + shlex.quote(package),
+                evidence="Flatpak export path",
+            )
+        )
+
+    package = _pipx_owner(executable, realpath)
+    if package:
+        direct_matches.append(
+            PackageMatch(
+                "pipx",
+                package,
+                "pipx uninstall " + shlex.quote(package),
+                evidence="pipx exposed app",
+            )
+        )
+
+    package = _uv_owner(executable, realpath)
+    if package:
+        direct_matches.append(
+            PackageMatch(
+                "uv",
+                package,
+                "uv tool uninstall " + shlex.quote(package),
+                evidence="uv exposed app",
+            )
+        )
+
+    package = _cargo_owner(executable, realpath)
+    if package:
+        direct_matches.append(
+            PackageMatch(
+                "cargo",
+                package,
+                "cargo uninstall " + shlex.quote(package),
+                evidence="Cargo installed binary",
+            )
+        )
+
+    package = _brew_owner(paths)
+    if package:
+        direct_matches.append(
+            PackageMatch(
+                "brew",
+                package,
+                "brew uninstall " + shlex.quote(package),
+                evidence="Homebrew file record",
+            )
+        )
+
+    matches = direct_matches
+    matches.sort(key=lambda match: (match.manager, match.package))
+    note = None
+    if not matches:
+        note = (
+            "no supported package manager claims this executable; "
+            "it may have been installed manually or by another installer"
+        )
+    path_setup = find_path_setup(executable.parent)
+    return Result(
+        command,
+        str(executable),
+        str(realpath),
+        matches[0].manager if matches else "unknown",
+        matches[0].package if matches else None,
+        matches[0].uninstall if matches else None,
+        note,
+        matches,
+        path_setup,
+    )
+
+
+def _format_matches(
+    matches: Sequence[PackageMatch],
+    no_limit: bool,
+    *,
+    path_records: bool = False,
+) -> list[str]:
+    visible = list(matches)
+    if not path_records:
+        visible.sort(key=lambda match: (match.manager, match.package.casefold()))
+    shown = visible if no_limit else visible[:20]
+    lines = []
+    for match in shown:
+        evidence = " ({})".format(match.evidence) if path_records else ""
+        description = "    - {}{}: {}".format(match.manager, evidence, match.package)
+        if match.section:
+            description += " [section: {}]".format(match.section)
+        if match.display_name and match.display_name.casefold() != match.package.casefold():
+            description += " ({})".format(match.display_name)
+        lines.append(description)
+        lines.append("        uninstall: " + match.uninstall)
+    remaining = len(visible) - len(shown)
+    if remaining:
+        lines.append(
+            "  ... {} more matches; use --no-limit to display all selected matches".format(remaining)
+        )
+    return lines
+
+
+def _json_result(
+    command: str,
+    result: Result,
+    matches: Sequence[PackageMatch],
+) -> dict[str, object]:
+    visible = list(matches)
+    visible.sort(key=lambda match: (match.evidence == "name match", match.manager, match.package))
+    primary = visible[0] if visible else None
+    note = result.note
+
+    return {
+        "command": command,
+        "executable": result.executable,
+        "realpath": result.realpath,
+        "manager": primary.manager if primary else "unknown",
+        "package": primary.package if primary else None,
+        "uninstall": primary.uninstall if primary else None,
+        "note": note,
+        "matches": [
+            {
+                "manager": match.manager,
+                "package": match.package,
+                "uninstall": match.uninstall,
+                "evidence": match.evidence,
+                "display_name": match.display_name,
+                "section": match.section,
+            }
+            for match in visible
+        ],
+        "path_setup": [
+            {"file": item.file, "line": item.line, "entry": item.entry}
+            for item in result.path_setup
+        ],
+    }
+
+
+def _format(result: Result, no_limit: bool = False) -> str:
+    lines = [result.command]
+    if result.executable is None:
+        lines.append("  manager:    unknown")
+        lines.append("  note:       " + (result.note or "command not found"))
+        return "\n".join(lines)
+    lines.extend(
+        [
+            "  PATH resolution:",
+            "    executable: " + result.executable,
+            "    realpath:   " + (result.realpath or result.executable),
+        ]
+    )
+    if result.matches:
+        lines.append("  package manager records:")
+        lines.extend(_format_matches(result.matches, no_limit, path_records=True))
+    else:
+        lines.append("  manager:    unknown")
+    if result.note:
+        lines.append("  note:       " + result.note)
+    if result.path_setup:
+        lines.append("  PATH entry sources:")
+        for item in result.path_setup:
+            lines.append(f"    {item.file}:{item.line}  {item.entry}")
+        lines.append(
+            "  note:       these sources show where PATH is recorded, not how "
+            "the executable was installed"
+        )
+    else:
+        lines.append(
+            "  PATH entry sources: none found in checked shell config files or "
+            "recognized Fish universal paths"
+        )
+    return "\n".join(lines)
+
+
+def _format_search(
+    command: str,
+    matches: Sequence[PackageMatch],
+    no_limit: bool = False,
+) -> str:
+    lines = [command]
+    if not matches:
+        lines.extend(
+            [
+                "  manager:    unknown",
+                "  note:       no installed dpkg, snap, flatpak, pipx, uv, Cargo, or Homebrew package matched",
+            ]
+        )
+    else:
+        lines.append("  package matches:")
+        lines.extend(_format_matches(matches, no_limit))
+    return "\n".join(lines)
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="pkgwho",
+        description=(
+            "Search commands, installed packages, and Fontconfig fonts."
+        ),
+    )
+    parser.add_argument("--version", action="version", version="%(prog)s " + __version__)
+    parser.add_argument(
+        "--type", choices=("command", "package", "font", "all"), default="all",
+        help="what to search (default: all)",
+    )
+    parser.add_argument(
+        "commands", nargs="+", metavar="QUERY",
+        help="command, package, or font search text",
+    )
+    parser.add_argument(
+        "--no-limit",
+        action="store_true",
+        help="display every selected match without the default 20-match limit",
+    )
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="output all results as a JSON array",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        metavar="FILE",
+        dest="output_file",
+        help="write output to FILE instead of standard output",
+    )
+    args = parser.parse_args(argv)
+    output: list[Any] = []
+    unresolved = False
+    for command in args.commands:
+        results: dict[str, Any] = {}
+        found = False
+        if args.type in ("command", "all"):
+            result = inspect(command)
+            found = result.executable is not None
+            results["command"] = (
+                _json_result(command, result, result.matches)
+                if args.json else _format(result, args.no_limit)
+            )
+        if args.type in ("package", "all"):
+            matches = _search_installed_packages(command)
+            found = found or bool(matches)
+            results["package"] = (
+                {"query": command, "matches": [
+                    {"manager": m.manager, "package": m.package,
+                     "uninstall": m.uninstall, "evidence": m.evidence,
+                     "display_name": m.display_name, "section": m.section}
+                    for m in matches
+                ], "note": None if matches else "no installed package matched"}
+                if args.json else _format_search(command, matches, args.no_limit)
+            )
+        if args.type in ("font", "all"):
+            font_matches = search_fonts(command)
+            found = found or bool(font_matches)
+            results["font"] = (
+                _font_result(command, font_matches)
+                if args.json else _format_fonts(command, font_matches, args.no_limit)
+            )
+        unresolved = unresolved or not found
+        if args.type == "all":
+            if args.json:
+                output.append({"query": command, **results})
+            else:
+                output.append("\n\n".join(
+                    name.capitalize() + " search:\n" + results[name]
+                    for name in ("command", "package", "font")
+                ))
+        else:
+            output.append(results[args.type])
+    if args.json:
+        rendered_output = json.dumps(output, ensure_ascii=False, indent=2)
+    else:
+        rendered_output = "\n\n".join(output)
+    if args.output_file is not None:
+        try:
+            Path(args.output_file).write_text(rendered_output + "\n", encoding="utf-8")
+        except OSError as exc:
+            parser.error("could not write output file {!r}: {}".format(args.output_file, exc))
+    else:
+        print(rendered_output)
+    return 1 if unresolved else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pkgwho/shell_config.py

@@ -0,0 +1,209 @@
+"""Static discovery of PATH entries in common user shell configuration files."""
+
+from __future__ import annotations
+
+import os
+import re
+import shlex
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Mapping, Sequence
+
+
+@dataclass(frozen=True)
+class PathSetup:
+    """A shell configuration line that adds an executable directory to PATH."""
+
+    file: str
+    line: int
+    entry: str
+
+
+def _configuration_files(home: Path, env: Mapping[str, str]) -> list[tuple[str, Path]]:
+    """Return supported user configuration files in a stable shell order."""
+    zdotdir = Path(env.get("ZDOTDIR") or home).expanduser().absolute()
+    xdg_config_home = (
+        Path(env.get("XDG_CONFIG_HOME") or home / ".config").expanduser().absolute()
+    )
+    fish_dir = xdg_config_home / "fish"
+
+    candidates: list[tuple[str, Path]] = [
+        ("bash", home / ".bashrc"),
+        ("bash", home / ".bash_profile"),
+        ("bash", home / ".bash_login"),
+        ("bash", home / ".profile"),
+    ]
+    candidates.append(("fish", fish_dir / "config.fish"))
+    try:
+        candidates.extend(
+            ("fish", path)
+            for path in sorted(fish_dir.joinpath("conf.d").glob("*.fish"))
+        )
+    except OSError:
+        pass
+    candidates.extend(
+        ("zsh", zdotdir / name)
+        for name in (".zshenv", ".zprofile", ".zshrc", ".zlogin")
+    )
+
+    unique: dict[str, tuple[str, Path]] = {}
+    for shell, candidate in candidates:
+        key = os.path.abspath(os.fspath(candidate))
+        unique.setdefault(key, (shell, candidate))
+    return list(unique.values())
+
+
+def _expand_path_entry(value: str, home: Path) -> str | None:
+    """Expand only literal home-directory forms; never evaluate shell code."""
+    value = value.strip().rstrip(";")
+    if not value:
+        return None
+
+    quote: str | None = None
+    if len(value) >= 2 and value[0] == value[-1] and value[0] in "\"'":
+        quote = value[0]
+        value = value[1:-1]
+    else:
+        if value.startswith("\"") or value.startswith("'"):
+            quote = value[0]
+            value = value[1:]
+        if value.endswith("\"") or value.endswith("'"):
+            value = value[:-1]
+
+    # Single quotes suppress both tilde and variable expansion in these shells.
+    if quote != "'":
+        if value == "~":
+            value = str(home)
+        elif value.startswith("~/"):
+            value = str(home / value[2:])
+        value = value.replace("${HOME}", str(home)).replace("$HOME", str(home))
+
+    if not os.path.isabs(value) or "$" in value or "~" in value:
+        return None
+    return os.path.normpath(value)
+
+
+def _path_values(line: str, shell: str) -> Sequence[str]:
+    """Extract literal path candidates from common Bash/Zsh and Fish forms."""
+    try:
+        tokens = shlex.split(line, comments=True, posix=False)
+    except ValueError:
+        return ()
+    if not tokens:
+        return ()
+
+    values: list[str] = []
+    if shell in {"bash", "zsh"}:
+        assignment_tokens = tokens[1:] if tokens[0] == "export" else tokens[:1]
+        for token in assignment_tokens:
+            if token.startswith("PATH=") or token.startswith("PATH+="):
+                assignment_value = token.split("=", 1)[1]
+                values.extend(assignment_value.split(":"))
+
+    if shell == "fish":
+        if tokens[0] == "set" and "PATH" in tokens[1:]:
+            path_index = tokens.index("PATH", 1)
+            flags = tokens[1:path_index]
+            exported = "--export" in flags or any(
+                flag.startswith("-") and "x" in flag[1:] for flag in flags
+            )
+            if exported:
+                for token in tokens[path_index + 1 :]:
+                    values.extend(token.split(":"))
+
+        if tokens[0] == "fish_add_path":
+            values.extend(token for token in tokens[1:] if not token.startswith("-"))
+
+    return values
+
+
+def _fish_user_paths(fish_dir: Path, home: Path) -> list[PathSetup]:
+    """Read Fish v3 universal path records without executing shell config."""
+    variables_file = fish_dir / "fish_variables"
+    if not variables_file.is_file():
+        return []
+    try:
+        lines = variables_file.read_text(encoding="utf-8", errors="replace").splitlines()
+    except OSError:
+        return []
+
+    if "# VERSION: 3.0" not in lines:
+        return []
+
+    record = re.compile(
+        r"^SETUVAR(?:\s+--\S+)*\s+fish_user_paths:(.*)$"
+    )
+    escape = re.compile(rb"\\x([0-9a-fA-F]{2})")
+    latest: tuple[int, list[str]] | None = None
+    for line_number, line in enumerate(lines, start=1):
+        match = record.match(line)
+        if match is None:
+            continue
+        raw_value = match.group(1).encode("utf-8")
+        decoded = escape.sub(
+            lambda item: bytes((int(item.group(1), 16),)), raw_value
+        )
+        paths: list[str] = []
+        for raw_path in decoded.split(b"\x1e"):
+            value = raw_path.decode("utf-8", errors="replace")
+            expanded = _expand_path_entry(value, home)
+            if expanded is not None:
+                paths.append(expanded)
+        latest = (line_number, paths)
+
+    if latest is None:
+        return []
+    line_number, paths = latest
+    return [
+        PathSetup(
+            file=os.path.abspath(os.fspath(variables_file)),
+            line=line_number,
+            entry=f"Fish persistent PATH entry (fish_user_paths): {path}",
+        )
+        for path in paths
+    ]
+
+
+def find_path_setup(
+    executable_directory: Path,
+    *,
+    env: Mapping[str, str] | None = None,
+) -> list[PathSetup]:
+    """Find config lines that statically add ``executable_directory`` to PATH."""
+    current_env = os.environ if env is None else env
+    home = Path(current_env.get("HOME") or Path.home()).expanduser().absolute()
+    target = os.path.normpath(os.fspath(executable_directory.absolute()))
+    matches: list[PathSetup] = []
+
+    config_files = _configuration_files(home, current_env)
+    for shell, config_file in config_files:
+        try:
+            lines = config_file.read_text(encoding="utf-8", errors="replace").splitlines()
+        except OSError:
+            continue
+        for line_number, line in enumerate(lines, start=1):
+            for value in _path_values(line, shell):
+                expanded = _expand_path_entry(value, home)
+                if expanded == target:
+                    matches.append(
+                        PathSetup(
+                            file=os.path.abspath(os.fspath(config_file)),
+                            line=line_number,
+                            entry=line.strip(),
+                        )
+                    )
+                    break
+
+    xdg_config_home = Path(
+        current_env.get("XDG_CONFIG_HOME") or home / ".config"
+    ).expanduser().absolute()
+    fish_dir = xdg_config_home / "fish"
+    target = os.path.normpath(os.fspath(executable_directory.absolute()))
+    fish_entry_prefix = "Fish persistent PATH entry (fish_user_paths): "
+    matches.extend(
+        item
+        for item in _fish_user_paths(fish_dir, home)
+        if item.entry.removeprefix(fish_entry_prefix) == target
+    )
+
+    return matches

pkgwho-0.1.1.dist-info/METADATA

@@ -0,0 +1,141 @@
+Metadata-Version: 2.5
+Name: pkgwho
+Version: 0.1.1
+Summary: Identify the packages that provide commands and fonts on Linux
+Project-URL: Documentation, https://github.com/tos-kamiya/pkgwho#readme
+Project-URL: Issues, https://github.com/tos-kamiya/pkgwho/issues
+Project-URL: Source, https://github.com/tos-kamiya/pkgwho
+Project-URL: Changelog, https://github.com/tos-kamiya/pkgwho/blob/main/release-notes.md
+Author-email: Toshihiro Kamiya <kamiya@mbj.nifty.com>
+License-Expression: MIT
+License-File: LICENSE.txt
+Keywords: command,font,linux,package manager,package ownership
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: System :: Installation/Setup
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# pkgwho
+
+Find which package manager installed a command or font on Linux, or search
+installed packages by name. pkgwho checks dpkg/apt, Snap, Flatpak, pipx, uv
+tools, Cargo, and Homebrew, and suggests how to remove packages. It never
+uninstalls anything automatically.
+
+## Installation
+
+Install directly from GitHub with [pipx](https://pipx.pypa.io/):
+
+```console
+pipx install git+https://github.com/tos-kamiya/pkgwho.git
+```
+
+## Usage
+
+Pass one or more search terms. By default, pkgwho searches commands, packages,
+and fonts for each term:
+
+```console
+pkgwho git snap flatpak
+pkgwho /usr/local/bin/my-command
+```
+
+The exit status is nonzero if any query has no result in the selected search
+types. In combined mode, a query succeeds if any of the searches finds a result.
+
+### `--type {command,package,font,all}`
+
+Choose what to search. The default is `all`.
+
+| Type | Search |
+| --- | --- |
+| `command` | Resolve a command in `PATH` or a file path and identify its package owner. |
+| `package` | Find installed package names by case-insensitive partial match, including libraries. |
+| `font` | Find installed font family or full names by case- and punctuation-insensitive partial match. |
+| `all` | Search all three independently. A package may appear in more than one result. |
+
+```console
+pkgwho --type command git
+pkgwho --type package chrome
+pkgwho --type font "Noto Sans"
+```
+
+Command searches report `unknown` when no supported manager claims the file.
+They also report matching PATH entries in Bash, Zsh, and Fish configuration,
+including Fish's `fish_user_paths`. These entries are not proof of installation;
+configuration files are read but never executed or modified.
+
+Font searches require Fontconfig's `fc-list`. Results include the font file and,
+when found in the dpkg or Homebrew formula database, its package and suggested
+uninstall command. Unowned files are still shown. An unavailable `fc-list` is
+reported and causes a nonzero exit status in font-only mode.
+
+### `--no-limit`
+
+Text output shows up to 20 matches per search. Use `--no-limit` to display all
+matches:
+
+```console
+pkgwho --type package nvidia --no-limit
+```
+
+### `--json`
+
+Emit a JSON array for one or more queries:
+
+```console
+pkgwho git unknown-tool --json
+```
+
+In combined mode, each array element contains `query`, `command`, `package`,
+and `font` fields. In single-type mode, each element contains that search's
+result directly. JSON includes all matches without the text output's default
+20-match limit.
+
+### `-o FILE`, `--output FILE`
+
+Write the selected output format to a file instead of standard output. Existing
+files are overwritten:
+
+```console
+pkgwho git --json --output results.json
+```
+
+### `-h`, `--help`
+
+Show command-line usage and exit.
+
+### `--version`
+
+Show the installed pkgwho version and exit.
+
+## Supported managers
+
+- **dpkg/apt**: queries dpkg's file ownership database.
+- **Snap**: checks commands exposed in `/snap/bin` against installed snaps.
+- **Flatpak**: recognizes application launchers exported in Flatpak's
+  `exports/bin` directories.
+- **pipx**: maps exposed applications from `pipx list` to their environments.
+- **uv**: maps exposed executables from `uv tool list` to installed tools.
+- **Cargo**: maps binaries from `cargo install --list` to installed crates.
+- **Homebrew**: queries installed formulae and matches files listed by Homebrew.
+
+## License
+
+`pkgwho` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

pkgwho-0.1.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+pkgwho/__about__.py,sha256=C3lXAQDT9nnQBBFS60poxgmFjhywLP_kULuM6BLaFTY,134
+pkgwho/__init__.py,sha256=tppZQyuZohMsdaWtpBs6sb6Vp5ygUW_Qi4oF3xG_1vs,112
+pkgwho/cli.py,sha256=lkW62mTO9l8jNsYLhC6s2VpKX76mNXR8ZHPcYTGtZ9U,27362
+pkgwho/shell_config.py,sha256=YCv2GByhpO1tHFIvdlBRRCnCd6ZL_c5lrz9ci730XR8,7141
+pkgwho-0.1.1.dist-info/METADATA,sha256=Usmf7rku-dfdFAaTnRRMPNaFGCH90hOf6QOGk4JMXtk,4977
+pkgwho-0.1.1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+pkgwho-0.1.1.dist-info/entry_points.txt,sha256=KGqb0_xsAmlqZtlwvuDRZBivmZg_lDczC8ttL2L6NgA,43
+pkgwho-0.1.1.dist-info/licenses/LICENSE.txt,sha256=9EoQyGLRu9D0o_LNkqCkRT2c-5LDEpBllUzwQ53PbTg,1104
+pkgwho-0.1.1.dist-info/RECORD,,

pkgwho-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pkgwho-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pkgwho = pkgwho.cli:main

pkgwho-0.1.1.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026-present Toshihiro Kamiya <kamiya@mbj.nifty.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.