jartify 0.1.1__py3-none-any.whl

jartify/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

jartify/__main__.py

@@ -0,0 +1,4 @@
+from jartify.cli import main
+
+if __name__ == "__main__":
+    main()

jartify/app.py

@@ -0,0 +1,221 @@
+"""`jartify-tui` — Textual TUI for interactive Artifactory searches.
+
+Layout:
+
+  * Top bar: Input field for the name pattern.
+  * Centre:  DataTable of hits (version / filename / repo / size).
+  * Bottom:  Detail pane showing all checksums + download URL for the
+             highlighted row.
+
+Bindings:
+
+  Enter   run the search
+  r       repeat last search
+  y       copy sha256 of the highlighted row to the clipboard (if
+          `pyperclip` is importable; otherwise prints to the log)
+  q       quit
+"""
+
+from __future__ import annotations
+
+import threading
+
+from textual import on, work
+from textual.app import App, ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.widgets import DataTable, Footer, Header, Input, Static
+
+from jartify import __version__, config
+from jartify.client import Artifact, ArtifactoryClient, ArtifactoryError
+
+
+HELP = (
+    "Type a filename pattern (wildcards * and ? allowed) and press Enter. "
+    "Highlight a row to see full checksums below. y copies sha256."
+)
+
+
+class DetailPane(Static):
+    DEFAULT_CSS = """
+    DetailPane {
+        padding: 1 2;
+        border: tall $accent;
+        height: auto;
+        min-height: 9;
+    }
+    """
+
+    def show(self, art: Artifact | None) -> None:
+        if art is None:
+            self.update(HELP)
+            return
+        size = f"{art.size:,} bytes" if art.size is not None else "-"
+        self.update(
+            f"[b]{art.filename}[/b]\n"
+            f"repo:    {art.repo}\n"
+            f"path:    {art.path}\n"
+            f"version: {art.display_version}\n"
+            f"size:    {size}\n"
+            f"sha256:  {art.sha256 or '-'}\n"
+            f"sha1:    {art.sha1 or '-'}\n"
+            f"md5:     {art.md5 or '-'}\n"
+            f"url:     {art.download_uri or '-'}"
+        )
+
+
+class JartifyApp(App):
+    CSS = """
+    #search {
+        dock: top;
+        margin: 1 2 0 2;
+    }
+    DataTable {
+        height: 1fr;
+        margin: 1 2 0 2;
+    }
+    #status {
+        dock: bottom;
+        height: 1;
+        padding: 0 2;
+        color: $text-muted;
+    }
+    """
+
+    BINDINGS = [
+        Binding("ctrl+c,q", "quit", "Quit"),
+        Binding("r", "repeat", "Repeat search"),
+        Binding("y", "copy_sha", "Copy sha256"),
+    ]
+
+    def __init__(self, client: ArtifactoryClient, repos, max_results):
+        super().__init__()
+        self.title = f"jartify {__version__}"
+        self.client = client
+        self.repos = repos
+        self.max_results = max_results
+        self._artifacts: list[Artifact] = []
+        self._last_pattern: str = ""
+        self._search_lock = threading.Lock()
+
+    def compose(self) -> ComposeResult:
+        yield Header(show_clock=False)
+        yield Input(placeholder="filename pattern (e.g. requests-*.whl)", id="search")
+        yield DataTable(id="results", zebra_stripes=True, cursor_type="row")
+        yield Vertical(DetailPane(HELP, id="detail"))
+        yield Static("", id="status")
+        yield Footer()
+
+    def on_mount(self) -> None:
+        table = self.query_one("#results", DataTable)
+        table.add_columns("Version", "Filename", "Repo", "Size")
+        self.query_one("#search", Input).focus()
+
+    def _set_status(self, text: str) -> None:
+        self.query_one("#status", Static).update(text)
+
+    @on(Input.Submitted, "#search")
+    def _on_submit(self, event: Input.Submitted) -> None:
+        pattern = event.value.strip()
+        if not pattern:
+            return
+        self._last_pattern = pattern
+        self._run_search(pattern)
+
+    def action_repeat(self) -> None:
+        if self._last_pattern:
+            self._run_search(self._last_pattern)
+
+    def action_copy_sha(self) -> None:
+        art = self._selected_artifact()
+        if art is None or not art.sha256:
+            self._set_status("no sha256 to copy")
+            return
+        try:
+            import pyperclip  # type: ignore
+
+            pyperclip.copy(art.sha256)
+            self._set_status(f"copied sha256 for {art.filename}")
+        except Exception:
+            self.log(f"sha256={art.sha256}")
+            self._set_status(f"pyperclip missing; sha256 printed to log")
+
+    @on(DataTable.RowHighlighted)
+    def _on_highlight(self, event: DataTable.RowHighlighted) -> None:
+        self.query_one("#detail", DetailPane).show(self._selected_artifact())
+
+    def _selected_artifact(self) -> Artifact | None:
+        table = self.query_one("#results", DataTable)
+        if not self._artifacts or table.cursor_row is None:
+            return None
+        if 0 <= table.cursor_row < len(self._artifacts):
+            return self._artifacts[table.cursor_row]
+        return None
+
+    @work(thread=True)
+    def _run_search(self, pattern: str) -> None:
+        # Only one search at a time.
+        if not self._search_lock.acquire(blocking=False):
+            return
+        try:
+            self.call_from_thread(self._set_status, f"searching for {pattern!r}…")
+            try:
+                hits = list(
+                    self.client.iter_artifacts(
+                        pattern, repos=self.repos, max_results=self.max_results
+                    )
+                )
+            except ArtifactoryError as exc:
+                self.call_from_thread(self._set_status, f"error: {exc}")
+                return
+            self.call_from_thread(self._populate, pattern, hits)
+        finally:
+            self._search_lock.release()
+
+    def _populate(self, pattern: str, hits: list[Artifact]) -> None:
+        table = self.query_one("#results", DataTable)
+        table.clear()
+        self._artifacts = hits
+        for a in hits:
+            size = f"{a.size:,}" if a.size is not None else "-"
+            table.add_row(a.display_version, a.filename, a.repo, size)
+        self._set_status(f"{len(hits)} hit(s) for {pattern!r}")
+        if hits:
+            self.query_one("#detail", DetailPane).show(hits[0])
+        else:
+            self.query_one("#detail", DetailPane).show(None)
+
+
+def main() -> int:
+    state = config.bootstrap()
+    if state != "ok":
+        print(config.USAGE)
+        if state == "created":
+            print(f"Wrote template at {config.CONFIG_PATH}. Edit it, then re-run.")
+        return 2
+
+    cfg = config.load() or {}
+    try:
+        auth, headers = config.resolve_auth(cfg)
+    except RuntimeError as exc:
+        print(f"error: {exc}")
+        return 2
+
+    settings = cfg.get("settings") or {}
+    base_url = (cfg.get("artifactory") or {}).get("url")
+    client = ArtifactoryClient(
+        base_url,
+        auth=auth,
+        headers=headers,
+        timeout=int(settings.get("timeout") or 30),
+    )
+    repos_raw = (cfg.get("artifactory") or {}).get("repos") or ""
+    repos = [r.strip() for r in repos_raw.split(",") if r.strip()] or None
+    max_results = int(settings.get("max_results") or 200)
+
+    JartifyApp(client, repos, max_results).run()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

jartify/cli.py

@@ -0,0 +1,147 @@
+"""`jartify` CLI entry point.
+
+Given a filename or substring/wildcard pattern, prints one row per
+matching artifact: version, filename, sha256.
+
+Default output is a human-readable aligned table. Use ``--json`` for
+machine-readable output.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from jartify import __version__, config
+from jartify.client import ArtifactoryClient, ArtifactoryError
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="jartify",
+        description=(
+            "Search Artifactory for a file and print version, filename, "
+            "and sha256 checksum."
+        ),
+    )
+    p.add_argument(
+        "pattern",
+        nargs="?",
+        help="Filename or wildcard pattern (e.g. 'requests-*.whl').",
+    )
+    p.add_argument(
+        "--repo",
+        action="append",
+        default=None,
+        help="Restrict to a repo (repeatable). Overrides config repos list.",
+    )
+    p.add_argument(
+        "--max",
+        type=int,
+        default=None,
+        help="Max number of results (defaults to settings.max_results).",
+    )
+    p.add_argument("--json", action="store_true", help="Emit JSON instead of a table.")
+    p.add_argument(
+        "--configure",
+        action="store_true",
+        help="Run interactive configuration and exit.",
+    )
+    p.add_argument("--version", action="version", version=f"jartify {__version__}")
+    return p
+
+
+def _print_table(rows: list[dict]) -> None:
+    if not rows:
+        print("No matches.")
+        return
+    headers = ("VERSION", "FILENAME", "SHA256")
+    widths = [
+        max(len(headers[0]), *(len(r["version"]) for r in rows)),
+        max(len(headers[1]), *(len(r["filename"]) for r in rows)),
+        max(len(headers[2]), *(len(r["sha256"]) for r in rows)),
+    ]
+    fmt = f"{{:<{widths[0]}}}  {{:<{widths[1]}}}  {{:<{widths[2]}}}"
+    print(fmt.format(*headers))
+    print(fmt.format("-" * widths[0], "-" * widths[1], "-" * widths[2]))
+    for r in rows:
+        print(fmt.format(r["version"], r["filename"], r["sha256"]))
+
+
+def _resolve_repos(args, cfg) -> list[str] | None:
+    if args.repo:
+        return args.repo
+    raw = (cfg.get("artifactory") or {}).get("repos") or ""
+    repos = [r.strip() for r in raw.split(",") if r.strip()]
+    return repos or None
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _build_parser().parse_args(argv)
+
+    if args.configure:
+        config.interactive_configure()
+        return 0
+
+    state = config.bootstrap()
+    if state != "ok":
+        print(config.USAGE)
+        if state == "created":
+            print(f"Wrote template at {config.CONFIG_PATH}. Edit it, then re-run.")
+        return 2
+
+    if not args.pattern:
+        _build_parser().print_help()
+        return 2
+
+    cfg = config.load() or {}
+    try:
+        auth, headers = config.resolve_auth(cfg)
+    except RuntimeError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+
+    settings = cfg.get("settings") or {}
+    base_url = (cfg.get("artifactory") or {}).get("url")
+    client = ArtifactoryClient(
+        base_url,
+        auth=auth,
+        headers=headers,
+        timeout=int(settings.get("timeout") or 30),
+    )
+
+    max_results = args.max or int(settings.get("max_results") or 200)
+    repos = _resolve_repos(args, cfg)
+
+    try:
+        artifacts = list(
+            client.iter_artifacts(args.pattern, repos=repos, max_results=max_results)
+        )
+    except ArtifactoryError as exc:
+        print(f"artifactory error: {exc}", file=sys.stderr)
+        return 1
+
+    rows = [
+        {
+            "version": a.display_version,
+            "filename": a.filename,
+            "sha256": a.sha256 or "-",
+            "repo": a.repo,
+            "path": a.path,
+            "size": a.size,
+            "download_uri": a.download_uri,
+        }
+        for a in artifacts
+    ]
+
+    if args.json:
+        print(json.dumps(rows, indent=2))
+    else:
+        _print_table(rows)
+
+    return 0 if rows else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

jartify/client.py

@@ -0,0 +1,181 @@
+"""Artifactory HTTP client.
+
+Thin wrapper around the Artifactory REST API covering the two calls
+jartify needs:
+
+  * ``search_artifacts`` -> ``/api/search/artifact?name=...``
+  * ``get_file_info``    -> ``/api/storage/<repo>/<path>``
+
+The storage endpoint returns the checksum block (md5/sha1/sha256) we
+report to the user.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Iterable, Iterator
+from urllib.parse import urljoin
+
+import requests
+from packaging.utils import parse_sdist_filename, parse_wheel_filename
+
+
+@dataclass
+class Artifact:
+    repo: str
+    path: str              # repo-relative path including filename
+    filename: str
+    version: str | None    # parsed from filename when possible
+    size: int | None
+    sha256: str | None
+    sha1: str | None
+    md5: str | None
+    download_uri: str | None
+
+    @property
+    def display_version(self) -> str:
+        return self.version or "-"
+
+
+_VERSION_RE = re.compile(r"-(\d[\w.+!-]*?)(?:[-.](?:py|cp|pp|jy|ip)\d|\.(?:tar|zip|whl|egg|jar|war|pom|rpm|deb)\b)")
+
+
+def _parse_version(filename: str) -> str | None:
+    """Best-effort version extraction from an artifact filename.
+
+    Handles wheels and sdists via the ``packaging`` library (PEP 427 /
+    PEP 625) and falls back to a lenient regex for other artifact
+    types (jars, rpms, raw archives, etc.).
+    """
+    lower = filename.lower()
+    try:
+        if lower.endswith(".whl"):
+            _, version, *_ = parse_wheel_filename(filename)
+            return str(version)
+        if lower.endswith((".tar.gz", ".zip")):
+            _, version = parse_sdist_filename(filename)
+            return str(version)
+    except Exception:
+        pass
+
+    m = _VERSION_RE.search(filename)
+    return m.group(1) if m else None
+
+
+class ArtifactoryError(RuntimeError):
+    pass
+
+
+class ArtifactoryClient:
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        auth=None,
+        headers: dict | None = None,
+        timeout: int = 30,
+        session: requests.Session | None = None,
+    ):
+        if not base_url:
+            raise ValueError("base_url is required")
+        self.base_url = base_url.rstrip("/")
+        if not self.base_url.endswith("/artifactory"):
+            self.base_url = self.base_url + "/artifactory"
+        self.timeout = timeout
+        self.session = session or requests.Session()
+        if auth is not None:
+            self.session.auth = auth
+        if headers:
+            self.session.headers.update(headers)
+        self.session.headers.setdefault("Accept", "application/json")
+
+    def _url(self, path: str) -> str:
+        return urljoin(self.base_url + "/", path.lstrip("/"))
+
+    def _get(self, path: str, **kwargs) -> dict:
+        resp = self.session.get(self._url(path), timeout=self.timeout, **kwargs)
+        if resp.status_code == 401:
+            raise ArtifactoryError("401 Unauthorized — check your token / username.")
+        if resp.status_code == 403:
+            raise ArtifactoryError("403 Forbidden — token lacks read permission.")
+        if resp.status_code >= 400:
+            raise ArtifactoryError(f"{resp.status_code} {resp.reason}: {resp.text[:300]}")
+        return resp.json()
+
+    def search_artifacts(
+        self,
+        name_pattern: str,
+        *,
+        repos: Iterable[str] | None = None,
+        max_results: int | None = None,
+    ) -> list[str]:
+        """Return a list of storage URIs matching the given name pattern.
+
+        ``name_pattern`` is matched by Artifactory using substring +
+        wildcard semantics (``*`` and ``?``).
+        """
+        params: dict = {"name": name_pattern}
+        if repos:
+            params["repos"] = ",".join(r for r in repos if r)
+        data = self._get("api/search/artifact", params=params)
+        uris = [row["uri"] for row in data.get("results", []) if "uri" in row]
+        if max_results is not None:
+            uris = uris[:max_results]
+        return uris
+
+    def get_file_info(self, storage_uri: str) -> Artifact | None:
+        """Fetch the storage info block for one URI and return an Artifact.
+
+        ``storage_uri`` is a full URL as returned by Artifactory's search
+        endpoints (``.../api/storage/<repo>/<path>``). Folders have no
+        ``checksums`` field and are skipped (returns None).
+        """
+        resp = self.session.get(storage_uri, timeout=self.timeout)
+        if resp.status_code >= 400:
+            raise ArtifactoryError(
+                f"{resp.status_code} fetching {storage_uri}: {resp.text[:200]}"
+            )
+        info = resp.json()
+        if "checksums" not in info:
+            return None  # directory, not a file
+
+        repo = info.get("repo", "")
+        rel_path = info.get("path", "").lstrip("/")
+        filename = rel_path.rsplit("/", 1)[-1]
+        checksums = info.get("checksums") or {}
+        size = info.get("size")
+        try:
+            size_int = int(size) if size is not None else None
+        except (TypeError, ValueError):
+            size_int = None
+
+        return Artifact(
+            repo=repo,
+            path=rel_path,
+            filename=filename,
+            version=_parse_version(filename),
+            size=size_int,
+            sha256=checksums.get("sha256"),
+            sha1=checksums.get("sha1"),
+            md5=checksums.get("md5"),
+            download_uri=info.get("downloadUri"),
+        )
+
+    def iter_artifacts(
+        self,
+        name_pattern: str,
+        *,
+        repos: Iterable[str] | None = None,
+        max_results: int | None = None,
+    ) -> Iterator[Artifact]:
+        """Convenience: search + fetch each hit's file info, yielding Artifacts."""
+        for uri in self.search_artifacts(
+            name_pattern, repos=repos, max_results=max_results
+        ):
+            try:
+                art = self.get_file_info(uri)
+            except ArtifactoryError:
+                continue
+            if art is not None:
+                yield art

jartify/config.py

@@ -0,0 +1,137 @@
+import os
+from pathlib import Path
+
+import yaml
+
+
+CONFIG_DIR = Path.home() / ".local" / "etc" / "jartify"
+CONFIG_PATH = CONFIG_DIR / "config.yaml"
+
+
+TEMPLATE = """\
+artifactory:
+  url: https://artifactory.example.com
+  # Optional: restrict searches to a comma-separated list of repos.
+  # Leave empty to search across all repos the token can see.
+  repos: ""
+
+authentication:
+  # Env var holding your Artifactory identity token or API key.
+  token_env: ARTIFACTORY_TOKEN
+  # Optional username for basic auth. If unset, the token is sent as a
+  # bearer token (identity token) and no username is needed.
+  # username: your.name
+
+settings:
+  timeout: 30
+  retries: 3
+  # Max number of search hits to show. Artifactory itself caps this at
+  # whatever is configured server-side; this is a client-side guard.
+  max_results: 200
+"""
+
+
+PLACEHOLDERS = {
+    ("artifactory", "url"): "https://artifactory.example.com",
+}
+
+
+USAGE = f"""\
+jartify configuration
+=====================
+
+Config file: {CONFIG_PATH}
+
+Required fields:
+  artifactory.url            Base URL of your Artifactory instance
+                             (without /artifactory suffix)
+
+Authentication:
+  Set your Artifactory identity token in the env var named by
+  authentication.token_env (default: ARTIFACTORY_TOKEN):
+
+      export ARTIFACTORY_TOKEN=your_token_here
+
+Edit the file above, then re-run:  jartify <pattern>  (or jartify-tui)
+"""
+
+
+def write_template():
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_PATH.write_text(TEMPLATE)
+
+
+def load():
+    if not CONFIG_PATH.exists():
+        return None
+    with CONFIG_PATH.open() as f:
+        return yaml.safe_load(f) or {}
+
+
+def _get(cfg, path):
+    node = cfg
+    for key in path:
+        if not isinstance(node, dict):
+            return None
+        node = node.get(key)
+    return node
+
+
+def is_configured(cfg):
+    for path, placeholder in PLACEHOLDERS.items():
+        if _get(cfg, path) == placeholder:
+            return False
+        if not _get(cfg, path):
+            return False
+    return True
+
+
+def interactive_configure():
+    print("Let's configure jartify.\n")
+
+    url = input("Artifactory URL (e.g. https://artifactory.example.com): ").strip()
+    repos = input("Repos to search (comma-separated, blank for all): ").strip()
+    token_env = input(
+        "Env var holding your identity token [ARTIFACTORY_TOKEN]: "
+    ).strip() or "ARTIFACTORY_TOKEN"
+
+    content = TEMPLATE
+    content = content.replace("https://artifactory.example.com", url)
+    content = content.replace('repos: ""', f'repos: "{repos}"')
+    content = content.replace(
+        "token_env: ARTIFACTORY_TOKEN",
+        f"token_env: {token_env}",
+    )
+
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_PATH.write_text(content)
+    print(f"\nWrote {CONFIG_PATH}")
+
+    if not os.getenv(token_env):
+        print(f"\nRemember to set {token_env} in your shell:")
+        print(f"    export {token_env}=your_token_here")
+
+
+def bootstrap():
+    """Return 'created' / 'unconfigured' / 'ok'."""
+    if not CONFIG_PATH.exists():
+        write_template()
+        return "created"
+    cfg = load()
+    if not is_configured(cfg):
+        return "unconfigured"
+    return "ok"
+
+
+def resolve_auth(cfg):
+    """Return (auth, headers) tuple for requests. auth is None for token auth."""
+    token_env = _get(cfg, ("authentication", "token_env")) or "ARTIFACTORY_TOKEN"
+    username = _get(cfg, ("authentication", "username"))
+    token = os.getenv(token_env)
+    if not token:
+        raise RuntimeError(
+            f"Env var {token_env} is not set. Export your Artifactory token first."
+        )
+    if username:
+        return (username, token), {}
+    return None, {"Authorization": f"Bearer {token}"}

jartify-0.1.1.dist-info/METADATA

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: jartify
+Version: 0.1.1
+Summary: TUI and CLI for searching JFrog Artifactory artifacts (version, filename, sha256)
+Author-email: Jakob Holst <code@jakobholst.dk>
+License: MIT
+Project-URL: Homepage, https://gitlab.com/jakobholst/jartify
+Project-URL: Repository, https://gitlab.com/jakobholst/jartify
+Keywords: artifactory,jfrog,tui,textual,sha256,search
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Classifier: Topic :: System :: Archiving :: Packaging
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.28
+Requires-Dist: textual>=0.50
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: packaging>=23.0
+
+# jartify
+
+`jartify` is a small toolkit for querying a JFrog Artifactory instance
+from a terminal. It exposes two entry points:
+
+| Command         | Purpose                                                      |
+|-----------------|--------------------------------------------------------------|
+| `jartify`       | One-shot CLI: find a file, print version / filename / sha256 |
+| `jartify-tui`   | Textual TUI for interactive searching                        |
+
+Both share the same `~/.local/etc/jartify/config.yaml` and
+`$ARTIFACTORY_TOKEN` env var (name is configurable).
+
+## Install
+
+```bash
+pip install jartify
+```
+
+## Configure
+
+The first run writes a template config:
+
+```bash
+jartify --configure              # interactive
+# or just:
+jartify foo                      # writes a template, prints path, exits
+```
+
+Edit `~/.local/etc/jartify/config.yaml`:
+
+```yaml
+artifactory:
+  url: https://artifactory.example.com
+  repos: ""                      # optional comma-separated allowlist
+
+authentication:
+  token_env: ARTIFACTORY_TOKEN   # name of env var holding your token
+  # username: your.name          # uncomment for basic auth instead of bearer
+```
+
+Export your token:
+
+```bash
+export ARTIFACTORY_TOKEN=...
+```
+
+## CLI usage
+
+```bash
+# Find all requests wheels and print version / filename / sha256:
+jartify 'requests-*.whl'
+
+# Restrict to specific repos:
+jartify 'myapp-*.tar.gz' --repo pypi-local --repo pypi-releases
+
+# Machine-readable output:
+jartify 'myapp-*.whl' --json
+```
+
+Output:
+
+```
+VERSION  FILENAME                               SHA256
+-------  -------------------------------------  ----------------------------------------------------------------
+2.31.0   requests-2.31.0-py3-none-any.whl       4c491f82b8a8b4...
+2.32.3   requests-2.32.3-py3-none-any.whl       70761cfe03c773...
+```
+
+Exit codes: `0` on at least one hit, `1` on no hits, `2` on config / auth errors.
+
+## TUI usage
+
+```bash
+jartify-tui
+```
+
+Keys: type pattern → <kbd>Enter</kbd>, <kbd>r</kbd> repeats the last
+search, <kbd>y</kbd> copies the highlighted row's sha256,
+<kbd>q</kbd> quits.
+
+## Releasing
+
+### One-time: register the PyPI trusted publisher
+
+PyPI has no API for this — the form is behind your login + 2FA. The
+helper script opens the right page and prints the values to type:
+
+```bash
+python scripts/register-pypi-publisher.py
+```
+
+It reads the project name from `pyproject.toml` and the GitLab
+namespace/repo from `git remote get-url origin`, so there's nothing to
+look up. In PyPI's "Add a new pending publisher" form, pick the GitLab
+tab and paste the printed values.
+
+### Each release
+
+Push to `main` with a bumped `version` in `pyproject.toml`. GitLab CI
+runs `python -m build`, mints a short-lived PyPI token via OIDC
+trusted publishing, and uploads with `twine upload --skip-existing`.
+Pushes that do not bump the version are no-ops.

jartify-0.1.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+jartify/__init__.py,sha256=rnObPjuBcEStqSO0S6gsdS_ot8ITOQjVj_-P1LUUYpg,22
+jartify/__main__.py,sha256=8ISVZj6Z_1V5G7deRmvCWZChtyfz64hjYRbnDjB5fxk,68
+jartify/app.py,sha256=xBOG2Y5kz0ykT_-o4c0WouBtpxK462q9LyhJMUlKRos,6993
+jartify/cli.py,sha256=ezhX_blxtnBhYp20aIUJAoS0dOVvXqY4gGmDtd-AAy8,4090
+jartify/client.py,sha256=xM4bwSm6b6wfiAkvB2Yteuq1SzNTgeJPTcjNSPau3m0,5984
+jartify/config.py,sha256=zaZpUITHglOkoxJuCk0cPvSO9cHdPWkqW-uQOoWqaQw,3726
+jartify-0.1.1.dist-info/METADATA,sha256=9YFCzeXw5LVSA9odEJvtiiRJrVAicIX-g3Ee9SUvt70,3862
+jartify-0.1.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+jartify-0.1.1.dist-info/entry_points.txt,sha256=0__k0dMkyGyriV8fKWs1RMzRrzlocK43cQTHM8BIHCc,76
+jartify-0.1.1.dist-info/top_level.txt,sha256=7UBHvm5EM_GZfaH4Vj8zhsv9LL7yF3LdBVIEFR97P0Q,8
+jartify-0.1.1.dist-info/RECORD,,

jartify-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

jartify-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+jartify = jartify.cli:main
+jartify-tui = jartify.app:main

jartify-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+jartify