freshenup 3.0.0__py3-none-any.whl

freshenup/__init__.py

@@ -0,0 +1,3 @@
+"""freshenup — pick outdated Homebrew and Mac App Store items to upgrade or uninstall."""
+
+__version__ = "3.0.0"

freshenup/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

freshenup/cli.py

@@ -0,0 +1,131 @@
+"""Command-line entry: parse flags, then orchestrate scan → pick → act."""
+
+from __future__ import annotations
+
+import argparse
+import re
+import shutil
+import sys
+
+from . import system
+from .models import Item, Kind, Node
+from .nodes import build_formula_nodes, collapse_casks
+from .pick import pick, preview
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parse_args(argv)
+    if args.preview is not None:
+        print(preview(args.preview))
+        return 0
+    nodes = _gather(refresh=args.update)
+    if not nodes:
+        print("Nothing outdated.")
+        return 0
+    selection = pick(nodes)
+    if selection is None:
+        return 0
+    if selection.uninstall is not None:
+        _uninstall(selection.uninstall)
+    else:
+        _update(selection.nodes)
+    return 0
+
+
+def _parse_args(argv: list[str] | None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="freshenup",
+        description="Pick outdated Homebrew and Mac App Store items to upgrade or uninstall.",
+    )
+    parser.add_argument("-u", "--update", action="store_true", help="run `brew update` first")
+    parser.add_argument("--preview", metavar="NODE", help=argparse.SUPPRESS)
+    return parser.parse_args(argv)
+
+
+def _gather(*, refresh: bool) -> list[Node]:
+    has_mas = shutil.which("mas") is not None
+    kinds = "formulae, casks, and App Store apps" if has_mas else "formulae and casks"
+    print(f"Scanning for outdated {kinds}…", file=sys.stderr)
+    scanned = system.scan(refresh=refresh, has_mas=has_mas)
+    return [
+        *build_formula_nodes(scanned.formulae, scanned.leaves, system.uses),
+        *collapse_casks(scanned.casks, system.deps_of),
+        *_mas_nodes(scanned.mas),
+    ]
+
+
+def _mas_nodes(apps: list[Item]) -> list[Node]:
+    # Display a slugified name + the last 3 id digits (near-unique, brew-like); the numeric id in
+    # itself.mas_id drives the action.
+    return [
+        Node(kind=Kind.MAS, name=f"{_slug(app.name)}-{app.mas_id[-3:]}", itself=app) for app in apps
+    ]
+
+
+def _slug(name: str) -> str:
+    return re.sub(r"[^a-z0-9]+", "-", name.lower()).strip("-")
+
+
+def _items(node: Node) -> list[Item]:
+    items = list(node.members)
+    if node.itself is not None:
+        items.append(node.itself)
+    return items
+
+
+def _update(nodes: list[Node]) -> None:
+    formulae: list[str] = []
+    casks: list[str] = []
+    mas_ids: list[str] = []
+    for node in nodes:
+        for item in _items(node):
+            if item.kind is Kind.CASK:
+                casks.append(item.name)
+            elif item.kind is Kind.MAS:
+                mas_ids.append(item.mas_id)
+            else:
+                formulae.append(item.name)
+    system.upgrade(Kind.FORMULA, _unique(formulae))
+    _upgrade_casks(_unique(casks))
+    system.upgrade(Kind.MAS, _unique(mas_ids))
+
+
+def _upgrade_casks(tokens: list[str]) -> None:
+    """Upgrade casks, but first handle any whose .app is owned by another user (brew would need
+    sudo and fail): offer to chown it back, else skip that cask."""
+    if not tokens:
+        return
+    me = system.current_user()
+    blocked = dict(system.blocked_casks(tokens, system.apps_of, system.owner_of, me))
+    approved = [token for token in tokens if token not in blocked]
+    for token, owner in blocked.items():
+        prompt = (
+            f"{token} is owned by {owner} — brew needs sudo to upgrade it. "
+            "chown to you first? [y/N] "
+        )
+        if not _confirm(prompt):
+            print(f"  skipped {token} (owned by {owner})", file=sys.stderr)
+        elif system.chown_cask(token, me):
+            approved.append(token)
+        else:
+            print(f"  chown failed; skipped {token}", file=sys.stderr)
+    system.upgrade(Kind.CASK, sorted(approved))
+
+
+def _uninstall(node: Node) -> None:
+    if not _confirm(f"Uninstall {node.name} ({node.kind.value})? [y/N] "):
+        print(f"  skipped {node.name}", file=sys.stderr)
+        return
+    mas_id = node.itself.mas_id if node.itself is not None else ""
+    system.uninstall(node.kind, node.name, mas_id)
+
+
+def _confirm(prompt: str) -> bool:
+    try:
+        return input(prompt).strip().lower() == "y"
+    except EOFError:
+        return False
+
+
+def _unique(names: list[str]) -> list[str]:
+    return sorted({name for name in names if name})

freshenup/models.py

@@ -0,0 +1,39 @@
+"""Domain types: the outdated Item the rest of freshenup works with."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+class Kind(Enum):
+    FORMULA = "formula"
+    CASK = "cask"
+    MAS = "mas"
+
+    @property
+    def label(self) -> str:
+        return {Kind.FORMULA: "(formula)", Kind.CASK: "(cask)", Kind.MAS: "(App Store)"}[self]
+
+
+@dataclass(frozen=True, slots=True)
+class Item:
+    """One outdated package and its version bump. `mas_id` is set only for App Store apps."""
+
+    kind: Kind
+    name: str
+    current: str
+    latest: str
+    mas_id: str = ""
+
+
+@dataclass(frozen=True, slots=True)
+class Node:
+    """One fzf row: a top-level package, optionally its own outdated Item (`itself`), plus any
+    outdated members folded under it — a formula's outdated dependencies, or casks folded under a
+    cask that depends on them."""
+
+    kind: Kind
+    name: str
+    itself: Item | None = None
+    members: tuple[Item, ...] = ()

freshenup/nodes.py

@@ -0,0 +1,62 @@
+"""Pure node-building: group outdated Items into the rows freshenup shows in fzf.
+
+Both builders take injected lookups (`uses`, `deps_of`) for their brew/receipt queries, so the
+grouping logic is unit-tested without any subprocess.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Iterable
+
+from .models import Item, Kind, Node
+
+
+def build_formula_nodes(
+    outdated: list[Item],
+    leaves: set[str],
+    uses: Callable[[str], Iterable[str]],
+) -> list[Node]:
+    """Group outdated formulae under their leaf (installed-on-request) formula: an outdated leaf
+    is its own node; an outdated dependency folds under the leaves that require it (`uses` gives a
+    formula's recursive dependents)."""
+    selves: dict[str, Item] = {}
+    member_map: dict[str, list[Item]] = {}
+    for item in outdated:
+        if item.name in leaves:
+            selves[item.name] = item
+        else:
+            for dependent in uses(item.name):
+                if dependent in leaves:
+                    member_map.setdefault(dependent, []).append(item)
+    names = sorted(selves.keys() | member_map.keys())
+    return [
+        Node(
+            kind=Kind.FORMULA,
+            name=name,
+            itself=selves.get(name),
+            members=tuple(member_map.get(name, ())),
+        )
+        for name in names
+    ]
+
+
+def collapse_casks(
+    casks: list[Item],
+    deps_of: Callable[[str], Iterable[str]],
+) -> list[Node]:
+    """Fold an outdated cask under an outdated cask that depends on it (e.g. a version-band cask
+    under its wrapper) so the pair shows as one row. `deps_of` gives a cask's cask dependencies."""
+    by_name = {cask.name: cask for cask in casks}
+    outdated = by_name.keys()
+    deps = {cask.name: [d for d in deps_of(cask.name) if d in outdated] for cask in casks}
+    folded = {dep for dep_list in deps.values() for dep in dep_list}
+    return [
+        Node(
+            kind=Kind.CASK,
+            name=cask.name,
+            itself=cask,
+            members=tuple(by_name[d] for d in deps[cask.name]),
+        )
+        for cask in casks
+        if cask.name not in folded
+    ]

freshenup/parse.py

@@ -0,0 +1,88 @@
+"""Pure parsers: raw ``brew``/``mas`` output and cask receipts → domain Items.
+
+The only I/O-free layer — every function takes text and returns data, so the bug-prone parsing
+(version extraction, JSON shapes) is unit-tested against fixtures without invoking brew.
+"""
+
+from __future__ import annotations
+
+import re
+
+from pydantic import BaseModel, Field, TypeAdapter
+
+from .models import Item, Kind
+
+# brew outdated --verbose lines: "name (1.0, 1.1) < 1.2" (formula), "name (1.0) != 1.2" (cask).
+# A cask version can carry a comma-suffix that is part of the version (e.g. dotnet
+# "8.0.422,8.0.28"); keep it and strip only a trailing build hash.
+_TRAILING_HASH = re.compile(r",[0-9a-fA-F]{16,}$")
+_OP = re.compile(r"^\s*(?:<|!=)\s*")
+
+
+def parse_brew_outdated(kind: Kind, text: str) -> list[Item]:
+    items: list[Item] = []
+    for line in text.splitlines():
+        open_paren = line.find(" (")
+        if open_paren < 0:
+            continue
+        rest = line[open_paren + 2 :]
+        close_paren = rest.find(")")
+        if close_paren < 0:
+            continue
+        installed = rest[:close_paren]
+        latest = _OP.sub("", rest[close_paren + 1 :])
+        current = installed.split(", ")[-1]  # newest of the installed versions
+        items.append(
+            Item(
+                kind=kind,
+                name=line[:open_paren],
+                current=_TRAILING_HASH.sub("", current),
+                latest=_TRAILING_HASH.sub("", latest),
+            )
+        )
+    return items
+
+
+class _MasApp(BaseModel):
+    adam_id: int = Field(alias="adamID")
+    name: str
+    current: str = Field(alias="version", default="")
+    latest: str = Field(alias="newVersion")
+
+
+_MAS_APPS = TypeAdapter(list[_MasApp])
+
+
+def parse_mas(text: str) -> list[Item]:
+    return [
+        Item(kind=Kind.MAS, name=a.name, current=a.current, latest=a.latest, mas_id=str(a.adam_id))
+        for a in _MAS_APPS.validate_json(text)
+    ]
+
+
+class _Dep(BaseModel):
+    full_name: str
+
+
+class _RuntimeDeps(BaseModel):
+    cask: list[_Dep] = []
+    formula: list[_Dep] = []
+
+
+class _Artifact(BaseModel):
+    # A cask's uninstall_artifacts is a heterogeneous list ({"app": [...]}, {"zap": [...]}, …);
+    # declaring only `app` (extra keys ignored) types the grab-bag without hand-digging.
+    app: list[str] = []
+
+
+class _Receipt(BaseModel):
+    runtime_dependencies: _RuntimeDeps = Field(default_factory=_RuntimeDeps)
+    uninstall_artifacts: list[_Artifact] = []
+
+
+def parse_receipt(text: str) -> tuple[list[str], list[str]]:
+    """Return (dependency cask tokens, installed .app names) from a cask install receipt."""
+    receipt = _Receipt.model_validate_json(text)
+    deps = [dep.full_name.rsplit("/", 1)[-1] for dep in receipt.runtime_dependencies.cask]
+    apps = [name for artifact in receipt.uninstall_artifacts for name in artifact.app]
+    return deps, apps

freshenup/pick.py

@@ -0,0 +1,87 @@
+"""fzf shell-out: present nodes for multi-select and render the preview pane."""
+
+from __future__ import annotations
+
+import os
+import shlex
+import subprocess
+import sys
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+
+from pydantic import TypeAdapter
+
+from .models import Node
+
+_PAYLOAD = TypeAdapter(list[Node])
+_ENV_PAYLOAD = "FRESHENUP_PAYLOAD"
+_UNINSTALL = "%%UNINSTALL%%"
+_HEADER = "enter=update  ctrl-x=uninstall highlighted  tab=toggle  ctrl-t=invert"
+
+
+def render_preview(node: Node) -> str:
+    header = node.name
+    if node.itself is not None:
+        header += f"  {node.itself.current} → {node.itself.latest}"
+    header += f"  {node.kind.label}"
+    members = [f"  {m.name:<22} {m.current} → {m.latest}" for m in node.members]
+    return "\n".join([header, *members])
+
+
+def preview(name: str) -> str:
+    """Render the preview for ``name``, reading the node payload written by ``pick``."""
+    path = os.environ.get(_ENV_PAYLOAD)
+    if not path:
+        return name
+    nodes = _PAYLOAD.validate_json(Path(path).read_bytes())
+    return next((render_preview(n) for n in nodes if n.name == name), name)
+
+
+@dataclass(frozen=True, slots=True)
+class Selection:
+    nodes: list[Node]
+    uninstall: Node | None
+
+
+def pick(nodes: list[Node]) -> Selection | None:
+    """Show the fzf menu; return the chosen nodes (or a single node to uninstall), or None."""
+    by_name = {node.name: node for node in nodes}
+    with tempfile.NamedTemporaryFile("wb", suffix=".json", delete=False) as tmp:
+        tmp.write(_PAYLOAD.dump_json(nodes))
+        payload = tmp.name
+    preview_cmd = f"{shlex.quote(sys.executable)} -m freshenup --preview {{}}"
+    try:
+        proc = subprocess.run(
+            [
+                "fzf",
+                "-m",
+                "--bind",
+                "load:select-all",
+                "--bind",
+                "ctrl-t:toggle-all",
+                "--bind",
+                f"ctrl-x:print({_UNINSTALL})+deselect-all+accept",
+                "--header",
+                _HEADER,
+                "--preview",
+                preview_cmd,
+                "--preview-window",
+                "right,55%",
+            ],
+            input="\n".join(sorted(by_name)),
+            text=True,
+            stdout=subprocess.PIPE,
+            env={**os.environ, _ENV_PAYLOAD: payload},
+        )
+    finally:
+        os.unlink(payload)
+    if proc.returncode != 0:
+        return None
+    lines = [line for line in proc.stdout.splitlines() if line]
+    if not lines:
+        return None
+    if lines[0] == _UNINSTALL:
+        target = by_name.get(lines[1]) if len(lines) > 1 else None
+        return Selection(nodes=[], uninstall=target)
+    return Selection(nodes=[by_name[line] for line in lines if line in by_name], uninstall=None)

freshenup/system.py

@@ -0,0 +1,152 @@
+"""I/O shell: run brew/mas, scan concurrently, and act on selections.
+
+Thin by design — the logic lives in the pure parse/nodes functions; this module just shells out
+and wires their injected lookups (``uses``, ``deps_of``, ``apps_of``, ``owner_of``) to real
+queries. The one pure function here, ``blocked_casks``, takes its filesystem access injected so
+it is unit-tested without touching ``/Applications``.
+"""
+
+from __future__ import annotations
+
+import os
+import pwd
+import subprocess
+from collections.abc import Callable, Iterable
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from functools import cache
+from pathlib import Path
+
+from .models import Item, Kind
+from .parse import parse_brew_outdated, parse_mas, parse_receipt
+
+_BREW = "brew"
+_MAS = "mas"
+_APPS = Path("/Applications")
+
+
+def current_user() -> str:
+    return pwd.getpwuid(os.getuid()).pw_name
+
+
+def _capture(*args: str) -> str:
+    """stdout of a command, or "" if it fails — scans tolerate a missing or erroring tool."""
+    proc = subprocess.run(args, capture_output=True, text=True)
+    return proc.stdout if proc.returncode == 0 else ""
+
+
+@dataclass(frozen=True, slots=True)
+class Scan:
+    formulae: list[Item]
+    casks: list[Item]
+    mas: list[Item]
+    leaves: set[str]
+
+
+def scan(*, refresh: bool, has_mas: bool) -> Scan:
+    if refresh:
+        print("Refreshing Homebrew…", flush=True)
+        subprocess.run([_BREW, "update"], stdout=subprocess.DEVNULL)
+    # brew's per-call startup is ~2.5s, so run the independent lookups concurrently.
+    with ThreadPoolExecutor(max_workers=4) as pool:
+        formulae = pool.submit(_capture, _BREW, "outdated", "--formula", "--verbose")
+        casks = pool.submit(_capture, _BREW, "outdated", "--cask", "--verbose")
+        leaves = pool.submit(_capture, _BREW, "leaves", "--installed-on-request")
+        mas = pool.submit(_capture, _MAS, "outdated", "--json") if has_mas else None
+    mas_text = mas.result().strip() if mas is not None else ""
+    return Scan(
+        formulae=parse_brew_outdated(Kind.FORMULA, formulae.result()),
+        casks=parse_brew_outdated(Kind.CASK, casks.result()),
+        mas=parse_mas(mas_text) if mas_text else [],
+        leaves=set(leaves.result().split()),
+    )
+
+
+def uses(name: str) -> list[str]:
+    """Installed formulae that depend on ``name`` (recursively)."""
+    return _capture(_BREW, "uses", "--installed", "--recursive", name).split()
+
+
+@cache
+def _caskroom() -> Path:
+    prefix = _capture(_BREW, "--prefix").strip() or "/opt/homebrew"
+    return Path(prefix) / "Caskroom"
+
+
+def _receipt(token: str) -> Path:
+    return _caskroom() / token / ".metadata" / "INSTALL_RECEIPT.json"
+
+
+def deps_of(token: str) -> list[str]:
+    """Cask tokens that cask ``token`` depends on (from its install receipt)."""
+    receipt = _receipt(token)
+    if not receipt.exists():
+        return []
+    deps, _apps = parse_receipt(receipt.read_text())
+    return deps
+
+
+def apps_of(token: str) -> list[str]:
+    """Installed .app bundle names for cask ``token`` (from its install receipt)."""
+    receipt = _receipt(token)
+    if not receipt.exists():
+        return []
+    _deps, apps = parse_receipt(receipt.read_text())
+    return apps
+
+
+def owner_of(app: str) -> str | None:
+    """Owning username of ``/Applications/<app>``, or None if absent/unknown."""
+    try:
+        return pwd.getpwuid((_APPS / app).stat().st_uid).pw_name
+    except FileNotFoundError, KeyError:
+        return None
+
+
+def blocked_casks(
+    tokens: Iterable[str],
+    apps_of: Callable[[str], Iterable[str]],
+    owner_of: Callable[[str], str | None],
+    me: str,
+) -> list[tuple[str, str]]:
+    """Return (token, owner) for casks whose installed .app is owned by someone else (typically
+    root, after a vendor self-updater reinstalled it) — brew can't upgrade those without sudo."""
+    blocked: list[tuple[str, str]] = []
+    for token in tokens:
+        for app in apps_of(token):
+            owner = owner_of(app)
+            if owner is not None and owner != me:
+                blocked.append((token, owner))
+                break
+    return blocked
+
+
+def chown_cask(token: str, me: str) -> bool:
+    """chown the cask's installed .app bundle(s) back to ``me`` (needs sudo). True on success."""
+    ok = True
+    for app in apps_of(token):
+        path = _APPS / app
+        if path.exists():
+            result = subprocess.run(["sudo", "chown", "-R", f"{me}:admin", str(path)])
+            ok = ok and result.returncode == 0
+    return ok
+
+
+def upgrade(kind: Kind, names: list[str]) -> None:
+    if not names:
+        return
+    if kind is Kind.MAS:
+        subprocess.run(["sudo", _MAS, "upgrade", *names])
+    else:
+        flag = "--cask" if kind is Kind.CASK else "--formula"
+        subprocess.run([_BREW, "upgrade", flag, *names])
+
+
+def uninstall(kind: Kind, name: str, mas_id: str = "") -> None:
+    if kind is Kind.CASK:
+        subprocess.run([_BREW, "uninstall", "--cask", name])
+    elif kind is Kind.MAS:
+        if mas_id:
+            subprocess.run(["sudo", _MAS, "uninstall", mas_id])
+    elif subprocess.run([_BREW, "uninstall", "--formula", name]).returncode == 0:
+        subprocess.run([_BREW, "autoremove"])

freshenup-3.0.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: freshenup
+Version: 3.0.0
+Summary: Pick outdated Homebrew and Mac App Store items to upgrade or uninstall
+Project-URL: Homepage, https://github.com/akirayamamoto/freshenup
+Project-URL: Repository, https://github.com/akirayamamoto/freshenup
+Project-URL: Issues, https://github.com/akirayamamoto/freshenup/issues
+Author: Akira Yamamoto
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,homebrew,macos,mas,updates
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: System :: Software Distribution
+Requires-Python: >=3.14
+Requires-Dist: pydantic>=2
+Description-Content-Type: text/markdown
+
+# freshenup
+
+Pick outdated Homebrew formulae and casks — and, optionally, outdated Mac App Store apps — from an `fzf` menu, then upgrade or uninstall them.
+
+A formula node is a top-level (leaf) formula that is outdated itself or has outdated dependencies beneath it; a cask or App Store app is a standalone node. Everything starts selected. Keys are shown in the `fzf` header. App Store rows show a slugified name; the numeric id drives the action via `mas` (which needs root, so a `sudo` prompt appears only when an App Store row is selected).
+
+## Install
+
+```bash
+brew install akirayamamoto/tap/freshenup
+```
+
+## Usage
+
+```bash
+freshenup          # scan and pick
+freshenup -u       # force `brew update` first (brew otherwise auto-refreshes at most once/24h)
+```
+
+- **enter** — upgrade the selected nodes
+- **ctrl-x** — uninstall the highlighted node (confirmed)
+- **tab** — toggle selection
+- **ctrl-t** — invert selection
+
+## Dependencies
+
+- [`fzf`](https://github.com/junegunn/fzf) — the interactive picker (installed automatically via Homebrew)
+- Python 3.14+ and [`pydantic`](https://docs.pydantic.dev) (bundled by the Homebrew install)
+- Homebrew
+- Optional: [`mas`](https://github.com/mas-cli/mas) for Mac App Store support (detected at runtime)
+
+## Development
+
+Managed with [`uv`](https://docs.astral.sh/uv/); lint/format with Ruff, type-checked with pyright (strict).
+
+```bash
+uv sync              # create the venv and install deps
+uv run pytest        # run tests
+uv run ruff check    # lint
+uv run ruff format   # format
+uv run pyright       # type-check (strict)
+```
+
+## License
+
+MIT

freshenup-3.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+freshenup/__init__.py,sha256=30Rqdqu16ZwHbevW8xhQgAKeiMYNakOaAOrEUmKerpU,115
+freshenup/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+freshenup/cli.py,sha256=KNcDdATAkiErwMzGR0bNwwEZV4-isfa0zt28aSVt9sY,4301
+freshenup/models.py,sha256=JuYOZekXOTrnuYRMziyswCS-eeDwQ8MD3I0gAcWdHlg,984
+freshenup/nodes.py,sha256=lhZjCPRDBgBsHMZb2IQMjN1S_-3RoqeoyX9Bz9oX534,2129
+freshenup/parse.py,sha256=7klyEdn2vbyJx3e28FvwKYxjyn1oVK3aoq-IML3bDts,2866
+freshenup/pick.py,sha256=P_O2TXpjpPXlnKZsrl0jFE_eLRizWu4DFdyi5ubxe68,2797
+freshenup/system.py,sha256=NyTTuxRAGbRzX6Q2GmNS1MRQQxIaxroCgDfTs-ET0I4,5216
+freshenup-3.0.0.dist-info/METADATA,sha256=sR-TLE1rSbZ4ZGd1MJzKRbup-moPaoBpvw6MhyUpE_Q,2375
+freshenup-3.0.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+freshenup-3.0.0.dist-info/entry_points.txt,sha256=jP1A6NkyAdxtjs4flEhgbaK9A3YpYgXT9GFPJO09rRg,49
+freshenup-3.0.0.dist-info/licenses/LICENSE,sha256=ZhLquyhQnoHk2SSFG0Mnxb9riWa5tYD2jXFufj_Crhw,1071
+freshenup-3.0.0.dist-info/RECORD,,

freshenup-3.0.0.dist-info/WHEEL

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

freshenup-3.0.0.dist-info/entry_points.txt

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

freshenup-3.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Akira Yamamoto
+
+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.