makepatch 0.2.8__tar.gz → 0.3.0__tar.gz

makepatch-0.3.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.py[cod]
+.venv/
+dist/
+build/
+.pytest_cache/
+.makepatch/

makepatch-0.3.0/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.5
+Name: makepatch
+Version: 0.3.0
+Summary: Git-based patch tool for Python packages: source forks (paperweight-style) and installed-package patches (pnpm-style)
+Project-URL: source, https://github.com/MadeByAlpha/makepatch.git
+Project-URL: issues, https://github.com/MadeByAlpha/makepatch/issues
+Classifier: Framework :: Hatch
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# makepatch
+
+A Git-based patch tool for Python packages that integrates with Hatchling.
+
+*Inspired by [paperweight](https://github.com/PaperMC/paperweight) and `pnpm patch`.*
+
+| Mode | Approach | Output |
+| --- | --- | --- |
+| Source patch (`makepatch src`) | Fetch an upstream Git repository at a pinned ref and patch it | sdist/wheel of a new package (fork) |
+| Package patch (`makepatch pkg`) | Patch installed packages in site-packages | patched virtual environment |
+
+There are two kinds of patches:
+
+- **Source patch**: created with `git diff` and applied with `git apply`. One patch per file.
+- **Feature patch**: created with `git format-patch -p --minimal --zero-commit --no-numbered` and applied with `git am --3way`. One patch per commit; available in source patch mode only.
+
+All patches are applied statically; there is no runtime monkey-patching.
+
+## Requirements
+
+- Python ≥ 3.13
+- Git ≥ 2.32
+
+## Source patch mode
+
+A fork repository needs only `pyproject.toml` and `patches/`.
+
+```toml
+[build-system]
+requires = ["hatchling", "makepatch"]
+build-backend = "hatchling.build"
+
+[project]            # Define the fork's metadata yourself.
+name = "requests-fork"
+version = "2.32.3.post1"
+dependencies = ["urllib3>=1.21.1,<3", "idna>=2.5,<4", "charset_normalizer>=2,<4", "certifi>=2017.4.17"]
+
+[tool.makepatch.source]
+upstream = "https://github.com/psf/requests.git"
+ref = "v2.32.3"                           # a 40-digit commit SHA is recommended; tags and branches work too
+include = { "src/requests" = "requests" } # upstream path → wheel path
+exclude = ["**/*.pyi"]                    # excluded from sdist/wheel (relative to include paths)
+work-exclude = ["docs/", "tests/"]        # excluded from work/ and the build tree (relative to the upstream root)
+# work-dir = "work"                       # default
+# patches-dir = "patches"                 # default
+
+[tool.hatch.build.hooks.makepatch]        # enables the build hook (settings live in the table above)
+
+[tool.hatch.build.targets.wheel]
+bypass-selection = true
+```
+
+Add `work/` and `.makepatch/` to `.gitignore` so that they are excluded from the sdist.
+
+### Excluding files
+
+Both options use gitignore syntax (including `!` negation), but differ in base path and effect.
+
+| Option | Base path | Effect |
+| --- | --- | --- |
+| `exclude` | each `include` path (e.g. `src/requests`) | Excluded from the sdist and wheel. Still present in `work/`. |
+| `work-exclude` | upstream root | Not checked out into `work/` or the build tree, via `git sparse-checkout`. Meant to save time and disk space. |
+
+- If a patch touches a file excluded by `work-exclude`, `makepatch src apply` and the build stop with an error.
+- After changing `work-exclude`, run `makepatch src apply` again.
+
+### Workflow
+
+```sh
+makepatch src apply     # fetch upstream → create work/ → apply source patches → git am feature patches
+# edit files in work/
+makepatch src fixup     # fold working tree changes into the source patch commit
+# or make regular commits in work/ → feature patches
+makepatch src rebuild   # regenerate patches/sources/** and patches/features/*.patch
+makepatch src status
+```
+
+The `work/` repository is laid out as follows:
+
+```
+<upstream ref>                 tag makepatch/base
+makepatch: source patches      tag makepatch/sources   ← patches/sources/<path>.patch
+<feature commits> ...                                  ← patches/features/NNNN-*.patch
+```
+
+If a feature patch conflicts, the `git am` session is left in place. Resolve the conflict in `work/`, run `git am --continue`, then run `makepatch src rebuild`.
+
+### Building
+
+```sh
+uv build
+```
+
+- The build hook does not use `work/`; it applies the patches afresh in `.makepatch/build/tree`. Uncommitted work therefore never leaks into the output.
+- The sdist contains the patched sources (`_makepatch/tree/`). Building a wheel from the sdist needs neither git nor network access.
+- Set `MAKEPATCH_OFFLINE=1` to use only the `.makepatch/upstream.git` cache.
+- Upstream's own build steps (C extensions, etc.) are not run. Pure Python sources are the target.
+
+## Package patch mode
+
+Install makepatch as a development dependency of the project.
+
+```sh
+uv add --dev makepatch
+```
+
+```sh
+uv run makepatch pkg edit requests     # create an editable copy in .makepatch/edit/requests@2.32.3/
+# edit files in the copy
+uv run makepatch pkg commit requests   # save patches/packages/requests@2.32.3.patch and apply it
+uv run makepatch pkg apply             # apply every patch (--check: only check that they apply)
+uv run makepatch pkg status
+uv run makepatch pkg revert requests   # restore the original files
+```
+
+- Patch files are named `<normalized name>@<version>.patch`, with paths relative to site-packages. An error is raised if the installed version differs.
+- Deleting a patch file and running `pkg apply` restores that package to its original state.
+- The patch directory can be changed with `[tool.makepatch.packages] patches-dir`.
+- `--python <interpreter>` targets a different environment.
+- Editable installs are not supported; edit their sources directly.
+
+### Compatibility with uv
+
+- **Cache protection**: on Linux, uv installs files from its cache as hardlinks by default (`--link-mode` selects clone, copy or symlink instead). makepatch never modifies files in place: it runs `git apply` on the affected files in a temporary directory and swaps them in with `os.replace`. Only the replaced paths get new inodes, so the uv cache stays untouched. The same holds in symlink mode.
+- **Records**: the hashes in `RECORD` are updated, and the applied state (`makepatch.json`, `makepatch.patch`) is written into the dist-info and registered in `RECORD`, so it is removed together with the package.
+- **Recovery after reinstall**: `uv sync` does not inspect the contents of installed files, so patches persist. If a reinstall or version change drops a patch, the `makepatch-startup.pth` installed by makepatch detects this at interpreter start-up and re-applies it.
+  - Normally it only compares the hashes of the patch files and markers.
+  - Only on a mismatch does it take the environment lock and do the same work as `pkg apply`.
+  - Disable it with `MAKEPATCH_DISABLE_STARTUP=1`.
+  - It is skipped when the interpreter runs with `-I` (isolated), as when uv queries an interpreter.
+
+## Development
+
+```sh
+uv sync
+uv run pytest
+```

makepatch-0.3.0/README.md

@@ -0,0 +1,137 @@
+# makepatch
+
+A Git-based patch tool for Python packages that integrates with Hatchling.
+
+*Inspired by [paperweight](https://github.com/PaperMC/paperweight) and `pnpm patch`.*
+
+| Mode | Approach | Output |
+| --- | --- | --- |
+| Source patch (`makepatch src`) | Fetch an upstream Git repository at a pinned ref and patch it | sdist/wheel of a new package (fork) |
+| Package patch (`makepatch pkg`) | Patch installed packages in site-packages | patched virtual environment |
+
+There are two kinds of patches:
+
+- **Source patch**: created with `git diff` and applied with `git apply`. One patch per file.
+- **Feature patch**: created with `git format-patch -p --minimal --zero-commit --no-numbered` and applied with `git am --3way`. One patch per commit; available in source patch mode only.
+
+All patches are applied statically; there is no runtime monkey-patching.
+
+## Requirements
+
+- Python ≥ 3.13
+- Git ≥ 2.32
+
+## Source patch mode
+
+A fork repository needs only `pyproject.toml` and `patches/`.
+
+```toml
+[build-system]
+requires = ["hatchling", "makepatch"]
+build-backend = "hatchling.build"
+
+[project]            # Define the fork's metadata yourself.
+name = "requests-fork"
+version = "2.32.3.post1"
+dependencies = ["urllib3>=1.21.1,<3", "idna>=2.5,<4", "charset_normalizer>=2,<4", "certifi>=2017.4.17"]
+
+[tool.makepatch.source]
+upstream = "https://github.com/psf/requests.git"
+ref = "v2.32.3"                           # a 40-digit commit SHA is recommended; tags and branches work too
+include = { "src/requests" = "requests" } # upstream path → wheel path
+exclude = ["**/*.pyi"]                    # excluded from sdist/wheel (relative to include paths)
+work-exclude = ["docs/", "tests/"]        # excluded from work/ and the build tree (relative to the upstream root)
+# work-dir = "work"                       # default
+# patches-dir = "patches"                 # default
+
+[tool.hatch.build.hooks.makepatch]        # enables the build hook (settings live in the table above)
+
+[tool.hatch.build.targets.wheel]
+bypass-selection = true
+```
+
+Add `work/` and `.makepatch/` to `.gitignore` so that they are excluded from the sdist.
+
+### Excluding files
+
+Both options use gitignore syntax (including `!` negation), but differ in base path and effect.
+
+| Option | Base path | Effect |
+| --- | --- | --- |
+| `exclude` | each `include` path (e.g. `src/requests`) | Excluded from the sdist and wheel. Still present in `work/`. |
+| `work-exclude` | upstream root | Not checked out into `work/` or the build tree, via `git sparse-checkout`. Meant to save time and disk space. |
+
+- If a patch touches a file excluded by `work-exclude`, `makepatch src apply` and the build stop with an error.
+- After changing `work-exclude`, run `makepatch src apply` again.
+
+### Workflow
+
+```sh
+makepatch src apply     # fetch upstream → create work/ → apply source patches → git am feature patches
+# edit files in work/
+makepatch src fixup     # fold working tree changes into the source patch commit
+# or make regular commits in work/ → feature patches
+makepatch src rebuild   # regenerate patches/sources/** and patches/features/*.patch
+makepatch src status
+```
+
+The `work/` repository is laid out as follows:
+
+```
+<upstream ref>                 tag makepatch/base
+makepatch: source patches      tag makepatch/sources   ← patches/sources/<path>.patch
+<feature commits> ...                                  ← patches/features/NNNN-*.patch
+```
+
+If a feature patch conflicts, the `git am` session is left in place. Resolve the conflict in `work/`, run `git am --continue`, then run `makepatch src rebuild`.
+
+### Building
+
+```sh
+uv build
+```
+
+- The build hook does not use `work/`; it applies the patches afresh in `.makepatch/build/tree`. Uncommitted work therefore never leaks into the output.
+- The sdist contains the patched sources (`_makepatch/tree/`). Building a wheel from the sdist needs neither git nor network access.
+- Set `MAKEPATCH_OFFLINE=1` to use only the `.makepatch/upstream.git` cache.
+- Upstream's own build steps (C extensions, etc.) are not run. Pure Python sources are the target.
+
+## Package patch mode
+
+Install makepatch as a development dependency of the project.
+
+```sh
+uv add --dev makepatch
+```
+
+```sh
+uv run makepatch pkg edit requests     # create an editable copy in .makepatch/edit/requests@2.32.3/
+# edit files in the copy
+uv run makepatch pkg commit requests   # save patches/packages/requests@2.32.3.patch and apply it
+uv run makepatch pkg apply             # apply every patch (--check: only check that they apply)
+uv run makepatch pkg status
+uv run makepatch pkg revert requests   # restore the original files
+```
+
+- Patch files are named `<normalized name>@<version>.patch`, with paths relative to site-packages. An error is raised if the installed version differs.
+- Deleting a patch file and running `pkg apply` restores that package to its original state.
+- The patch directory can be changed with `[tool.makepatch.packages] patches-dir`.
+- `--python <interpreter>` targets a different environment.
+- Editable installs are not supported; edit their sources directly.
+
+### Compatibility with uv
+
+- **Cache protection**: on Linux, uv installs files from its cache as hardlinks by default (`--link-mode` selects clone, copy or symlink instead). makepatch never modifies files in place: it runs `git apply` on the affected files in a temporary directory and swaps them in with `os.replace`. Only the replaced paths get new inodes, so the uv cache stays untouched. The same holds in symlink mode.
+- **Records**: the hashes in `RECORD` are updated, and the applied state (`makepatch.json`, `makepatch.patch`) is written into the dist-info and registered in `RECORD`, so it is removed together with the package.
+- **Recovery after reinstall**: `uv sync` does not inspect the contents of installed files, so patches persist. If a reinstall or version change drops a patch, the `makepatch-startup.pth` installed by makepatch detects this at interpreter start-up and re-applies it.
+  - Normally it only compares the hashes of the patch files and markers.
+  - Only on a mismatch does it take the environment lock and do the same work as `pkg apply`.
+  - Disable it with `MAKEPATCH_DISABLE_STARTUP=1`.
+  - It is skipped when the interpreter runs with `-I` (isolated), as when uv queries an interpreter.
+
+## Development
+
+```sh
+uv sync
+uv run pytest
+```

makepatch-0.3.0/pyproject.toml

@@ -0,0 +1,53 @@
+[project]
+name = "makepatch"
+version = "0.3.0"
+description = "Git-based patch tool for Python packages: source forks (paperweight-style) and installed-package patches (pnpm-style)"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+]
+classifiers = [
+    "Framework :: Hatch",
+    "Programming Language :: Python :: 3",
+]
+
+[dependency-groups]
+dev = [
+    "basedpyright>=1.40.1",
+    "hatchling>=1.21",
+    "mypy>=2.3.1",
+    "pytest>=8",
+    "ruff>=0.16.9",
+    "ty>=0.0.84",
+]
+
+
+[project.urls]
+source = "https://github.com/MadeByAlpha/makepatch.git"
+issues = "https://github.com/MadeByAlpha/makepatch/issues"
+
+[project.scripts]
+makepatch = "makepatch.cli:main"
+
+[project.entry-points.hatch]
+makepatch = "makepatch.hatch.hooks"
+
+
+[tool.uv]
+# Rebuild when the sources change while makepatch is used as a path dependency
+# (e.g. as a build requirement of a fork during development).
+cache-keys = [{ file = "pyproject.toml" }, { file = "src/**/*.py" }, { file = "src/*.pth" }]
+
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/makepatch"]
+
+[tool.hatch.build.targets.wheel.force-include]
+"src/makepatch-startup.pth" = "makepatch-startup.pth"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

makepatch-0.3.0/src/makepatch/__init__.py

@@ -0,0 +1,3 @@
+"""makepatch: git-based patching for Python packages."""
+
+__version__ = "0.1.0"

makepatch-0.3.0/src/makepatch/__main__.py

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

makepatch-0.3.0/src/makepatch/_startup.py

@@ -0,0 +1,90 @@
+"""Interpreter start-up check, imported from ``makepatch-startup.pth``.
+
+It only does work in an environment where ``makepatch pkg apply`` (or
+``pkg commit``) has run before, i.e. where ``<sys.prefix>/makepatch-state.json``
+exists. The fast path reads the patch files and the markers in the
+dist-info directories; only when they disagree (a package was reinstalled
+by uv/pip, or a patch was added, changed or removed) the patches are
+applied again, under the environment lock. Nothing is ever patched in
+memory: the result is the same as running ``makepatch pkg apply``.
+"""
+
+import hashlib
+import json
+import os
+import re
+import sys
+
+
+def _up_to_date(state):
+    applied = state.get("applied") or {}
+    patches_dir = state["patches_dir"]
+    try:
+        names = [n for n in os.listdir(patches_dir) if n.endswith(".patch")]
+    except FileNotFoundError:
+        names = []
+    if len(names) != len(applied):
+        return False
+    for name in names:
+        key = re.sub(r"[-_.]+", "-", name.partition("@")[0]).lower()
+        entry = applied.get(key)
+        if entry is None:
+            return False
+        with open(os.path.join(patches_dir, name), "rb") as fp:
+            sha = hashlib.sha256(fp.read()).hexdigest()
+        if entry.get("sha256") != sha:
+            return False
+        try:
+            with open(os.path.join(entry["dist_info"], "makepatch.json"), "rb") as fp:
+                marker = json.load(fp)
+        except (OSError, ValueError):
+            return False
+        if marker.get("sha256") != sha:
+            return False
+    return True
+
+
+def _repair(state):
+    from pathlib import Path
+
+    from makepatch.config import PackageConfig
+    from makepatch.package.apply import apply_all, locked
+    from makepatch.package.dist import Environment
+
+    env = Environment.current()
+    cfg = PackageConfig(root=Path(state["project"]), patches_dir=Path(state["patches_dir"]))
+    with locked(env):
+        # Another process may have repaired the environment meanwhile.
+        try:
+            with open(env.state_file, "rb") as fp:
+                if _up_to_date(json.load(fp)):
+                    return
+        except (OSError, ValueError, KeyError):
+            pass
+        results = apply_all(cfg, env)
+    for result in results:
+        if result.error:
+            sys.stderr.write(f"makepatch: warning: {result.error}\n")
+        elif result.action != "unchanged":
+            sys.stderr.write(f"makepatch: {result.key}: {result.action}\n")
+
+
+def _run():
+    if os.environ.get("MAKEPATCH_DISABLE_STARTUP") or sys.flags.isolated:
+        return
+    try:
+        with open(os.path.join(sys.prefix, "makepatch-state.json"), "rb") as fp:
+            state = json.load(fp)
+    except (OSError, ValueError):
+        return
+    if not os.path.isdir(state.get("project", "")):
+        return
+    if _up_to_date(state):
+        return
+    _repair(state)
+
+
+try:
+    _run()
+except Exception as exc:  # never break interpreter start-up
+    sys.stderr.write(f"makepatch: warning: start-up check failed: {exc}\n")

makepatch-0.3.0/src/makepatch/cli.py

@@ -0,0 +1,238 @@
+"""Command line interface: ``makepatch src ...`` and ``makepatch pkg ...``."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from makepatch import __version__
+from makepatch.config import PackageConfig, SourceConfig, find_project_root
+from makepatch.errors import MakepatchError
+from makepatch.term import paint
+
+# Colors for the actions reported by ``pkg`` commands.
+ACTION_STYLES = {
+    "applied": ("green",),
+    "reapplied": ("green",),
+    "would apply": ("cyan",),
+    "unchanged": ("dim",),
+    "reverted": ("yellow",),
+    "would revert": ("yellow",),
+    "not patched": ("dim",),
+}
+
+
+def _root(args: argparse.Namespace) -> Path:
+    return find_project_root(Path(args.project) if args.project else None)
+
+
+def _action(action: str) -> str:
+    return paint(action, *ACTION_STYLES.get(action, ()))
+
+
+def _cmd(command: str) -> str:
+    return paint(f"`{command}`", "cyan")
+
+
+def _err(text: str, *styles: str) -> str:
+    return paint(text, *styles, stream=sys.stderr)
+
+
+def _note(message: str) -> None:
+    print(f"{_err('note:', 'yellow', 'bold')} {message}", file=sys.stderr)
+
+
+def _env(args: argparse.Namespace):
+    from makepatch.package.dist import Environment
+
+    return Environment.for_python(args.python) if args.python else Environment.current()
+
+
+# -- src -------------------------------------------------------------------------------
+
+
+def cmd_src_apply(args: argparse.Namespace) -> int:
+    from makepatch.source import workspace
+
+    cfg = SourceConfig.load(_root(args))
+    work = workspace.setup(cfg, offline=args.offline, force=args.force)
+    print(f"{paint('work repository ready:', 'green')} {paint(str(work), 'bold')}")
+    return 0
+
+
+def cmd_src_rebuild(args: argparse.Namespace) -> int:
+    from makepatch.source import workspace
+
+    cfg = SourceConfig.load(_root(args))
+    sources, features = workspace.rebuild(cfg)
+    counts = f"{paint(str(sources), 'bold')} source patch(es) and {paint(str(features), 'bold')} feature patch(es)"
+    print(f"{paint('wrote', 'green')} {counts}")
+    return 0
+
+
+def cmd_src_fixup(args: argparse.Namespace) -> int:
+    from makepatch.source import workspace
+
+    cfg = SourceConfig.load(_root(args))
+    workspace.fixup(cfg)
+    print(f"{paint('folded changes into the source patch commit', 'green')}; run {_cmd('makepatch src rebuild')} to update patches")
+    return 0
+
+
+def cmd_src_status(args: argparse.Namespace) -> int:
+    from makepatch.source import workspace
+
+    cfg = SourceConfig.load(_root(args))
+    st = workspace.status(cfg)
+    print(f"{paint('upstream:', 'bold')}        {cfg.upstream} @ {paint(cfg.ref, 'cyan')} {paint(f'({st.base[:12]})', 'dim')}")
+    print(f"{paint('source files:', 'bold')}    {st.source_files}")
+    print(f"{paint('feature commits:', 'bold')} {st.features}")
+    print(f"{paint('dirty:', 'bold')}           {paint('yes', 'yellow') if st.dirty else paint('no', 'green')}")
+    if st.in_progress:
+        print(f"{paint('in progress:', 'bold')}     {paint(st.in_progress, 'yellow', 'bold')}")
+    return 0
+
+
+# -- pkg -------------------------------------------------------------------------------
+
+
+def cmd_pkg_edit(args: argparse.Namespace) -> int:
+    from makepatch.package import edit
+
+    cfg = PackageConfig.load(_root(args))
+    path = edit.edit(cfg, _env(args), args.package, force=args.force)
+    print(f"edit the files in {paint(str(path), 'bold')}, then run {_cmd(f'makepatch pkg commit {args.package}')}")
+    return 0
+
+
+def cmd_pkg_commit(args: argparse.Namespace) -> int:
+    from makepatch.package import edit
+
+    cfg = PackageConfig.load(_root(args))
+    patch, action = edit.commit(cfg, _env(args), args.package, keep=args.keep)
+    if patch is None:
+        print(f"no changes; {paint(args.package, 'bold')}: {_action(action)}")
+    else:
+        wrote = paint(str(patch.relative_to(cfg.root)), "bold")
+        print(f"{paint('wrote', 'green')} {wrote}; {paint(args.package, 'bold')}: {_action(action)}")
+    return 0
+
+
+def _print_results(results) -> int:
+    failed = 0
+    for r in results:
+        if r.error:
+            failed += 1
+            print(f"{_err(r.key, 'bold')}: {_err('failed:', 'red', 'bold')} {r.error}", file=sys.stderr)
+        else:
+            print(f"{paint(r.key, 'bold')}: {_action(r.action)}")
+    return 1 if failed else 0
+
+
+def cmd_pkg_apply(args: argparse.Namespace) -> int:
+    from makepatch.package.apply import apply_all, locked
+
+    cfg = PackageConfig.load(_root(args))
+    env = _env(args)
+    with locked(env):
+        return _print_results(apply_all(cfg, env, dry_run=args.check))
+
+
+def cmd_pkg_revert(args: argparse.Namespace) -> int:
+    from makepatch.package.apply import locked, revert, write_state
+
+    cfg = PackageConfig.load(_root(args))
+    env = _env(args)
+    with locked(env):
+        dist = env.find(args.package)
+        done = revert(dist)
+        write_state(cfg, env)
+    print(f"{paint(dist.key, 'bold')}: {_action('reverted' if done else 'not patched')}")
+    if done:
+        _note("the start-up hook re-applies it unless the patch file is removed")
+    return 0
+
+
+def cmd_pkg_status(args: argparse.Namespace) -> int:
+    from makepatch.package.apply import discover
+
+    cfg = PackageConfig.load(_root(args))
+    env = _env(args)
+    patches = discover(cfg)
+    dists = {d.key: d for d in env.distributions()}
+    keys = sorted(set(patches) | {k for k, d in dists.items() if d.marker()})
+    if not keys:
+        print(paint("no package patches", "dim"))
+    for key in keys:
+        patch, dist = patches.get(key), dists.get(key)
+        if dist is None:
+            state = paint("not installed", "red")
+        elif patch is None:
+            state = paint("patched, but the patch file is gone", "red")
+        elif dist.version != patch.version:
+            state = paint(f"version mismatch (installed {dist.version})", "red")
+        else:
+            marker = dist.marker()
+            if marker is None:
+                state = paint("not applied", "yellow")
+            elif marker.get("sha256") != patch.sha256:
+                state = paint("outdated", "yellow")
+            else:
+                state = paint("applied", "green")
+        print(f"{paint(patch.path.name if patch else key, 'bold')}: {state}")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="makepatch", description=__doc__)
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    parser.add_argument("-C", "--project", help="project directory (default: nearest pyproject.toml)")
+    modes = parser.add_subparsers(dest="mode", required=True)
+
+    src = modes.add_parser("src", help="source patch mode (fork an upstream git repository)")
+    src_cmds = src.add_subparsers(dest="command", required=True)
+    p = src_cmds.add_parser("apply", help="create the work repository and apply all patches")
+    p.add_argument("--offline", action="store_true", help="use the cached upstream only")
+    p.add_argument("--force", action="store_true", help="discard unsaved work in the work repository")
+    p.set_defaults(func=cmd_src_apply)
+    p = src_cmds.add_parser("rebuild", help="regenerate patches from the work repository")
+    p.set_defaults(func=cmd_src_rebuild)
+    p = src_cmds.add_parser("fixup", help="fold working tree changes into the source patches")
+    p.set_defaults(func=cmd_src_fixup)
+    p = src_cmds.add_parser("status", help="show the work repository state")
+    p.set_defaults(func=cmd_src_status)
+
+    pkg = modes.add_parser("pkg", help="package patch mode (patch installed distributions)")
+    pkg.add_argument("--python", help="interpreter of the target environment (default: the current one)")
+    pkg_cmds = pkg.add_subparsers(dest="command", required=True)
+    p = pkg_cmds.add_parser("edit", help="prepare an editable copy of an installed package")
+    p.add_argument("package")
+    p.add_argument("--force", action="store_true", help="discard an existing edit")
+    p.set_defaults(func=cmd_pkg_edit)
+    p = pkg_cmds.add_parser("commit", help="write the patch from an edit and apply it")
+    p.add_argument("package")
+    p.add_argument("--keep", action="store_true", help="keep the edit directory")
+    p.set_defaults(func=cmd_pkg_commit)
+    p = pkg_cmds.add_parser("apply", help="apply every package patch to the environment")
+    p.add_argument("--check", action="store_true", help="only check that the patches apply")
+    p.set_defaults(func=cmd_pkg_apply)
+    p = pkg_cmds.add_parser("revert", help="restore the original files of a package")
+    p.add_argument("package")
+    p.set_defaults(func=cmd_pkg_revert)
+    p = pkg_cmds.add_parser("status", help="show the state of every package patch")
+    p.set_defaults(func=cmd_pkg_status)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        return args.func(args)
+    except MakepatchError as exc:
+        print(f"{_err('makepatch: error:', 'red', 'bold')} {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())