usecli 0.1.77__tar.gz → 0.1.79__tar.gz

{usecli-0.1.77 → usecli-0.1.79}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: usecli
-Version: 0.1.77
+Version: 0.1.79
 Summary: A powerful Python CLI framework for building beautiful, developer-friendly command-line tools.
 Author: Edward Boswell
 Author-email: Edward Boswell <thememium@gmail.com>
@@ -18,12 +18,14 @@ Requires-Dist: rich>=15.0.0
 Requires-Dist: simple-term-menu>=1.6.6
 Requires-Dist: tomli>=2.4.1
 Requires-Dist: typer>=0.27.0
+Requires-Dist: pyinstaller>=6.21.0 ; extra == 'pyinstaller'
 Requires-Python: >=3.10
 Project-URL: Homepage, https://github.com/thememium/usecli
 Project-URL: Documentation, https://github.com/thememium/usecli
 Project-URL: Repository, https://github.com/thememium/usecli.git
 Project-URL: Issues, https://github.com/thememium/usecli/issues
 Project-URL: Changelog, https://github.com/thememium/usecli/blob/master/CHANGELOG.md
+Provides-Extra: pyinstaller
 Description-Content-Type: text/markdown
 
 <a name="readme-top"></a>
@@ -52,6 +54,7 @@ Description-Content-Type: text/markdown
     <li><a href="#about">About</a></li>
     <li><a href="#quick-start">Quick Start</a></li>
     <li><a href="#usage">Usage</a></li>
+    <li><a href="#entry-points--packaging">Entry Points &amp; Packaging</a></li>
     <li><a href="#development">Development</a></li>
     <li><a href="#contributing">Contributing</a></li>
     <li><a href="#license">License</a></li>
@@ -242,12 +245,131 @@ about        Show app info
 help         Show help
 init         Initialize usecli (usecli only)
 inspire      Random quote
+upgrade      Upgrade the application to the latest version
 make:command Create new command (usecli only)
 make:theme   Create new theme (usecli only)
+make:bundle  Build a standalone executable with PyInstaller (usecli only)
 ```
 
 <p align="right">(<a href="#readme-top">back to top</a>)</p>
 
+<!-- ENTRY POINTS & PACKAGING -->
+
+## Entry Points &amp; Packaging
+
+A usecli CLI can be exposed in several ways, depending on how you distribute and
+run it. There are three common setups — none requires anything but the base
+`usecli` install, and the optional bundler adds PyInstaller packaging on top.
+
+### 1. Default — console script (no entry point)
+
+The simplest setup. Declare a console script in your project's `pyproject.toml`:
+
+```toml
+[project.scripts]
+mycli = "usecli:main"
+```
+
+usecli resolves your project's config automatically from the current directory
+(config discovery), so no `main.py` is required. Install and run it:
+
+```sh
+uv add usecli
+uv run mycli --help
+```
+
+This is the **default** — no entry point file of your own is needed.
+
+### 2. Custom entry point — `main.py`
+
+If you want your own entry point, use the public runtime API. It works in both
+development and frozen bundles, and accepts an optional config path (the config
+file is always named `usecli.config.toml`):
+
+```python
+# main.py
+from usecli import run
+
+
+def main():
+    run()  # auto-detect project config
+    # run("path/to/usecli.config.toml")          # or point at a specific config
+
+
+if __name__ == "__main__":
+    main()
+```
+
+Run it in development (no PyInstaller required):
+
+```sh
+uv run python main.py --help
+```
+
+To expose the same entry point as a console script, point `[project.scripts]`
+at the `main` function in your `myapp` package (the usual `src/myapp` layout):
+
+```toml
+[project.scripts]
+myapp = "myapp:main"
+```
+
+Because `run()` injects the located config explicitly, a custom `main.py` works
+regardless of whether your CLI also has a `[project.scripts]` entry.
+
+### 3. Bundler — standalone executable (optional, requires PyInstaller)
+
+The bundler is an **optional** feature gated on PyInstaller being installed.
+Install it with:
+
+```sh
+uv add "usecli[pyinstaller]"
+```
+
+Once installed, a `make:bundle` command appears (usecli only) that builds your
+project into a standalone executable. It asks which mode to use via an
+interactive menu, and confirms before building (defaults to no unless `-y`):
+
+```sh
+uv run usecli make:bundle                  # menu: one file vs one folder + confirm
+uv run usecli make:bundle --mode onefile   # single-file executable
+uv run usecli make:bundle --mode onedir    # one-folder bundle
+uv run usecli make:bundle -y               # skip the confirmation
+uv run usecli make:bundle --mode onedir -y # fully programmatic
+uv run usecli make:bundle --mode onedir --zip -y  # one-folder bundle + zip
+```
+
+When building a **one-folder** bundle, `make:bundle` asks whether to also zip
+the folder into `dist/<name>.zip` (PyInstaller's recommended distribution
+format for one-folder mode). Pass `--zip` / `--no-zip` to skip the prompt and
+force a choice; with `-y` and no flag, zipping is skipped.
+
+A `usecli-bundle` console script wraps the same build, and you can drive it from
+Python too:
+
+```sh
+uv run usecli-bundle
+uv run usecli-bundle --mode onedir
+uv run usecli-bundle --mode onedir --zip
+```
+
+```python
+from usecli import pyinstaller
+
+pyinstaller()  # auto-detect config, single-file
+pyinstaller(mode="onedir")  # one-folder bundle
+pyinstaller(mode="onedir", zip=True)  # one-folder bundle + zip
+pyinstaller("path/to/usecli.config.toml")  # or point at a specific config
+```
+
+Output lands in `dist/` — `dist/mycli` for `onefile`, or a `dist/mycli/` folder
+containing the executable (plus `_internal/` with the bundled assets) for
+`onedir`. With `zip=True`, a `dist/mycli.zip` archive is created alongside the
+folder. `make:bundle` and `usecli-bundle` are only available when PyInstaller
+is installed.
+
+<p align="right">(<a href="#readme-top">back to top</a>)</p>
+
 <!-- DEVELOPMENT -->
 
 ## Development

{usecli-0.1.77 → usecli-0.1.79}/README.md

@@ -24,6 +24,7 @@
     <li><a href="#about">About</a></li>
     <li><a href="#quick-start">Quick Start</a></li>
     <li><a href="#usage">Usage</a></li>
+    <li><a href="#entry-points--packaging">Entry Points &amp; Packaging</a></li>
     <li><a href="#development">Development</a></li>
     <li><a href="#contributing">Contributing</a></li>
     <li><a href="#license">License</a></li>
@@ -214,12 +215,131 @@ about        Show app info
 help         Show help
 init         Initialize usecli (usecli only)
 inspire      Random quote
+upgrade      Upgrade the application to the latest version
 make:command Create new command (usecli only)
 make:theme   Create new theme (usecli only)
+make:bundle  Build a standalone executable with PyInstaller (usecli only)
 ```
 
 <p align="right">(<a href="#readme-top">back to top</a>)</p>
 
+<!-- ENTRY POINTS & PACKAGING -->
+
+## Entry Points &amp; Packaging
+
+A usecli CLI can be exposed in several ways, depending on how you distribute and
+run it. There are three common setups — none requires anything but the base
+`usecli` install, and the optional bundler adds PyInstaller packaging on top.
+
+### 1. Default — console script (no entry point)
+
+The simplest setup. Declare a console script in your project's `pyproject.toml`:
+
+```toml
+[project.scripts]
+mycli = "usecli:main"
+```
+
+usecli resolves your project's config automatically from the current directory
+(config discovery), so no `main.py` is required. Install and run it:
+
+```sh
+uv add usecli
+uv run mycli --help
+```
+
+This is the **default** — no entry point file of your own is needed.
+
+### 2. Custom entry point — `main.py`
+
+If you want your own entry point, use the public runtime API. It works in both
+development and frozen bundles, and accepts an optional config path (the config
+file is always named `usecli.config.toml`):
+
+```python
+# main.py
+from usecli import run
+
+
+def main():
+    run()  # auto-detect project config
+    # run("path/to/usecli.config.toml")          # or point at a specific config
+
+
+if __name__ == "__main__":
+    main()
+```
+
+Run it in development (no PyInstaller required):
+
+```sh
+uv run python main.py --help
+```
+
+To expose the same entry point as a console script, point `[project.scripts]`
+at the `main` function in your `myapp` package (the usual `src/myapp` layout):
+
+```toml
+[project.scripts]
+myapp = "myapp:main"
+```
+
+Because `run()` injects the located config explicitly, a custom `main.py` works
+regardless of whether your CLI also has a `[project.scripts]` entry.
+
+### 3. Bundler — standalone executable (optional, requires PyInstaller)
+
+The bundler is an **optional** feature gated on PyInstaller being installed.
+Install it with:
+
+```sh
+uv add "usecli[pyinstaller]"
+```
+
+Once installed, a `make:bundle` command appears (usecli only) that builds your
+project into a standalone executable. It asks which mode to use via an
+interactive menu, and confirms before building (defaults to no unless `-y`):
+
+```sh
+uv run usecli make:bundle                  # menu: one file vs one folder + confirm
+uv run usecli make:bundle --mode onefile   # single-file executable
+uv run usecli make:bundle --mode onedir    # one-folder bundle
+uv run usecli make:bundle -y               # skip the confirmation
+uv run usecli make:bundle --mode onedir -y # fully programmatic
+uv run usecli make:bundle --mode onedir --zip -y  # one-folder bundle + zip
+```
+
+When building a **one-folder** bundle, `make:bundle` asks whether to also zip
+the folder into `dist/<name>.zip` (PyInstaller's recommended distribution
+format for one-folder mode). Pass `--zip` / `--no-zip` to skip the prompt and
+force a choice; with `-y` and no flag, zipping is skipped.
+
+A `usecli-bundle` console script wraps the same build, and you can drive it from
+Python too:
+
+```sh
+uv run usecli-bundle
+uv run usecli-bundle --mode onedir
+uv run usecli-bundle --mode onedir --zip
+```
+
+```python
+from usecli import pyinstaller
+
+pyinstaller()  # auto-detect config, single-file
+pyinstaller(mode="onedir")  # one-folder bundle
+pyinstaller(mode="onedir", zip=True)  # one-folder bundle + zip
+pyinstaller("path/to/usecli.config.toml")  # or point at a specific config
+```
+
+Output lands in `dist/` — `dist/mycli` for `onefile`, or a `dist/mycli/` folder
+containing the executable (plus `_internal/` with the bundled assets) for
+`onedir`. With `zip=True`, a `dist/mycli.zip` archive is created alongside the
+folder. `make:bundle` and `usecli-bundle` are only available when PyInstaller
+is installed.
+
+<p align="right">(<a href="#readme-top">back to top</a>)</p>
+
 <!-- DEVELOPMENT -->
 
 ## Development

{usecli-0.1.77 → usecli-0.1.79}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "usecli"
-version = "0.1.77"
+version = "0.1.79"
 description = "A powerful Python CLI framework for building beautiful, developer-friendly command-line tools."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -27,6 +27,9 @@ license-files = ["LICEN[CS]E*"]
 name = "Edward Boswell"
 email = "thememium@gmail.com"
 
+[project.optional-dependencies]
+pyinstaller = ["pyinstaller>=6.21.0"]
+
 [project.urls]
 Homepage = "https://github.com/thememium/usecli"
 Documentation = "https://github.com/thememium/usecli"
@@ -36,7 +39,7 @@ Changelog = "https://github.com/thememium/usecli/blob/master/CHANGELOG.md"
 
 [project.scripts]
 usecli = "usecli:main"
-INVALID = "usecli:main"
+usecli-bundle = "usecli.bundler:cli"
 
 [build-system]
 requires = ["uv_build>=0.10.2,<0.11.0"]
@@ -47,6 +50,7 @@ dev = [
     "deptry>=0.25.1",
     "isort>=8.0.1",
     "poethepoet>=0.48.0",
+    "pyinstaller>=6.21.0",
     "pytest>=9.1.1",
     "pytest-cov>=7.1.0",
     "ruff>=0.16.1",

{usecli-0.1.77 → usecli-0.1.79}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "usecli"
-version = "0.1.77"
+version = "0.1.79"
 description = "A powerful Python CLI framework for building beautiful, developer-friendly command-line tools."
 readme = "README.md"
 authors = [{ name = "Edward Boswell", email = "thememium@gmail.com" }]
@@ -24,6 +24,9 @@ dependencies = [
 license = "MIT"
 license-files = ["LICEN[CS]E*"]
 
+[project.optional-dependencies]
+pyinstaller = ["pyinstaller>=6.21.0"]
+
 [project.urls]
 Homepage = "https://github.com/thememium/usecli"
 Documentation = "https://github.com/thememium/usecli"
@@ -33,7 +36,7 @@ Changelog = "https://github.com/thememium/usecli/blob/master/CHANGELOG.md"
 
 [project.scripts]
 usecli = "usecli:main"
-INVALID = "usecli:main"
+usecli-bundle = "usecli.bundler:cli"
 
 [build-system]
 requires = ["uv_build>=0.10.2,<0.11.0"]
@@ -44,6 +47,7 @@ dev = [
   "deptry>=0.25.1",
   "isort>=8.0.1",
   "poethepoet>=0.48.0",
+  "pyinstaller>=6.21.0",
   "pytest>=9.1.1",
   "pytest-cov>=7.1.0",
   "ruff>=0.16.1",
@@ -92,4 +96,3 @@ include = ["cli*"]
 
 [tool.setuptools.package-data]
 cli = ["**/*.toml", "**/*.j2"]
-

{usecli-0.1.77 → usecli-0.1.79}/src/usecli/__init__.py

@@ -42,6 +42,8 @@ _LAZY_EXPORTS = {
     "console": ("usecli.ui", "console"),
     "Spinner": ("usecli.progress", "Spinner"),
     "ProgressBar": ("usecli.progress", "ProgressBar"),
+    "pyinstaller": ("usecli.bundler", "pyinstaller"),
+    "run": ("usecli.entry", "run"),
 }
 
 
@@ -272,7 +274,7 @@ def _ensure_cli_initialized() -> None:
                     fail(error.__class__.__name__, str(error), 1)
 
         def invoke(self, ctx):
-            from click.exceptions import Exit
+            from click.exceptions import ClickException, Exit
 
             from usecli.cli.core.runtime import is_json_mode
 
@@ -304,7 +306,9 @@ def _ensure_cli_initialized() -> None:
                 styled_error = UsecliUsageError(e.message, ctx=e.ctx)
                 styled_error.show()
                 sys.exit(styled_error.exit_code)
-            except _TyperClickException as e:
+            # UsecliError extends real-click ClickException, not the vendored
+            # typer._click one — catch both, mirroring the JSON path.
+            except (_TyperClickException, ClickException) as e:
                 if hasattr(e, "show"):
                     e.show()
                 sys.exit(e.exit_code if hasattr(e, "exit_code") else 1)
@@ -365,6 +369,8 @@ __all__ = [
     "colors",
     "console",
     "main",
+    "pyinstaller",
+    "run",
     "theme",
 ]
 

usecli-0.1.79/src/usecli/bundler/__init__.py

@@ -0,0 +1,275 @@
+"""PyInstaller integration for usecli projects.
+
+Every usecli project is a thin layer over usecli: it provides a
+``usecli.config.toml`` plus ``commands/``, ``templates/`` and ``themes/`` that
+usecli loads at runtime. Packaging that with PyInstaller by hand requires a
+hand-written spec, ``--collect-all`` flags and a custom entry point that
+re-injects the bundle paths — easy to get wrong.
+
+:func:`pyinstaller` turns all of that into a one-liner::
+
+    from usecli import pyinstaller
+
+    pyinstaller()                   # auto-detect config from the current directory
+    pyinstaller("config.toml")      # or point at a specific config
+    pyinstaller(mode="onedir")      # or a one-folder (directory) bundle
+
+PyInstaller supports two operating modes (see
+https://pyinstaller.org/en/stable/operating-mode.html):
+
+* ``mode="onefile"`` (default): a single self-contained executable.
+* ``mode="onedir"``: a folder containing the executable plus its dependencies
+  (faster to start, easier to debug — you can inspect what was collected).
+
+It locates the project's ``usecli.config.toml`` (and the sibling
+``commands/``, ``templates/``, ``themes/`` and ``pyproject.toml``), then runs
+PyInstaller to produce a bundle named after the config's ``command_name``.
+PyInstaller is an optional dependency — install it with
+``pip install usecli[pyinstaller]`` (or ``uv add usecli[pyinstaller]``).
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import zipfile
+from collections.abc import Sequence
+from pathlib import Path
+
+from usecli.entry import BUNDLE_DATA_DIR
+
+_MODE_FLAG = {"onefile": "--onefile", "onedir": "--onedir"}
+_MODE_LABEL = {
+    "onefile": "a single-file executable",
+    "onedir": "a one-folder bundle",
+}
+
+
+def _resolve_config_path(
+    config_path: str | os.PathLike[str] | None,
+) -> Path:
+    """Return an absolute, existing path to the project's usecli.config.toml.
+
+    When ``config_path`` is ``None``, it is auto-detected: first by walking up
+    from the current directory, then (e.g. configs nested under ``cli/``) via a
+    bounded recursive search rooted at the detected project root.
+    """
+    if config_path is not None:
+        resolved = Path(config_path).resolve()
+        if not resolved.is_file():
+            raise FileNotFoundError(f"usecli.config.toml not found at: {resolved}")
+        return resolved
+
+    from usecli.shared.config.manager import resolve_config_path
+
+    return resolve_config_path(Path.cwd())
+
+
+def _find_pyproject(data_root: Path) -> Path | None:
+    """Find the nearest pyproject.toml walking up from the data dir."""
+    from usecli.shared.config.manager import find_project_pyproject
+
+    return find_project_pyproject(data_root)
+
+
+def _build_args(
+    config_path: Path,
+    entry_path: Path,
+    *,
+    name: str | None,
+    distpath: Path | None,
+    workpath: Path | None,
+    extra_args: Sequence[str] | None,
+    mode: str = "onefile",
+) -> list[str]:
+    from usecli.shared.config.manager import ConfigManager
+
+    if mode not in _MODE_FLAG:
+        raise ValueError(
+            f"Invalid mode {mode!r}; expected one of {sorted(_MODE_FLAG)}."
+        )
+
+    data_root = config_path.parent
+    command_name = name or (
+        ConfigManager._load_usecli_toml(config_path).get("command_name") or "usecli"
+    )
+    pyproject = _find_pyproject(data_root)
+
+    args: list[str] = [_MODE_FLAG[mode], "--name", command_name]
+    if distpath is not None:
+        args += ["--distpath", str(distpath)]
+    if workpath is not None:
+        args += ["--workpath", str(workpath)]
+    args += [
+        "--collect-all",
+        "usecli",
+        "--collect-all",
+        "pyfiglet",
+        "--add-data",
+        f"{data_root}{os.pathsep}{BUNDLE_DATA_DIR}",
+        "--paths",
+        str(data_root.parent),
+        "-y",
+    ]
+    if pyproject is not None:
+        args += ["--add-data", f"{pyproject}{os.pathsep}{BUNDLE_DATA_DIR}"]
+    if extra_args:
+        args += list(extra_args)
+    args.append(str(entry_path))
+    return args
+
+
+def _zip_bundle(dist_dir: Path, name: str) -> Path:
+    """Compress a one-folder bundle into ``<name>.zip``.
+
+    The archive is rooted at the bundle folder (``<name>/``) so users can
+    install the program simply by unzipping it — the distribution flow PyInstaller
+    describes for one-folder mode
+    (https://pyinstaller.org/en/stable/operating-mode.html#bundling-to-one-folder).
+    """
+    bundle_dir = dist_dir / name
+    if not bundle_dir.is_dir():
+        raise FileNotFoundError(
+            f"Cannot zip: expected one-folder bundle at {bundle_dir}."
+        )
+    target = dist_dir / f"{name}.zip"
+    with zipfile.ZipFile(target, "w", zipfile.ZIP_DEFLATED) as zf:
+        for path in sorted(bundle_dir.rglob("*")):
+            if path.is_file():
+                zf.write(path, arcname=f"{name}/{path.relative_to(bundle_dir)}")
+    return target
+
+
+def pyinstaller(
+    config_path: str | os.PathLike[str] | None = None,
+    *,
+    name: str | None = None,
+    mode: str = "onefile",
+    distpath: str | os.PathLike[str] | None = None,
+    workpath: str | os.PathLike[str] | None = None,
+    extra_args: Sequence[str] | None = None,
+    zip: bool = False,
+) -> int:
+    """Build an executable bundle for the given usecli project.
+
+    Args:
+        config_path: Optional path to a ``usecli.config.toml``. When omitted it
+            is auto-detected by walking up from the current directory.
+        name: Optional override for the executable name. Defaults to the
+            config's ``command_name``.
+        mode: ``"onefile"`` (single executable, default) or ``"onedir"``
+            (folder containing the executable plus its dependencies).
+        distpath: Output directory for the bundle (default: ``./dist``).
+        workpath: PyInstaller work directory (default: ``./build``).
+        extra_args: Additional PyInstaller CLI flags, e.g.
+            ``["--icon", "icon.icns"]``.
+        zip: When ``mode="onedir"`` and ``zip=True``, compress the resulting
+            folder into ``<name>.zip`` (alongside the folder in ``distpath``)
+            after a successful build — the distribution format PyInstaller
+            recommends for one-folder bundles. Ignored for ``mode="onefile"``.
+
+    Returns:
+        The PyInstaller exit code (``0`` on success).
+
+    Raises:
+        FileNotFoundError: if no config can be located / the given path is not
+            a file.
+        ValueError: if ``mode`` is not ``"onefile"`` or ``"onedir"``.
+        ImportError: if PyInstaller is not installed. Install with
+            ``pip install usecli[pyinstaller]``.
+    """
+    resolved = _resolve_config_path(config_path)
+    import usecli.entry as entry_module
+
+    entry_path = Path(entry_module.__file__)
+
+    try:
+        from PyInstaller.__main__ import run as _pyinstaller_run
+    except ImportError as exc:  # pragma: no cover - env dependent
+        raise ImportError(
+            "PyInstaller is required to build an executable. Install it with "
+            "`pip install usecli[pyinstaller]` (or `uv add usecli[pyinstaller]`)."
+        ) from exc
+
+    args = _build_args(
+        resolved,
+        entry_path,
+        name=name,
+        mode=mode,
+        distpath=Path(distpath) if distpath is not None else None,
+        workpath=Path(workpath) if workpath is not None else None,
+        extra_args=extra_args,
+    )
+
+    print(
+        f"[usecli] Packaging '{args[args.index('--name') + 1]}' "
+        f"from {resolved} as {_MODE_LABEL[mode]}..."
+    )
+    code = _pyinstaller_run(args)
+    if isinstance(code, int) and code != 0:
+        raise SystemExit(code)
+    result = int(code or 0)
+    if zip and mode == "onedir" and result == 0:
+        from usecli.shared.config.manager import ConfigManager
+
+        dist_dir = (
+            Path(distpath).resolve() if distpath is not None else Path.cwd() / "dist"
+        )
+        bundle_name = name or (
+            ConfigManager._load_usecli_toml(resolved).get("command_name") or "usecli"
+        )
+        zip_file = _zip_bundle(dist_dir, bundle_name)
+        print(f"[usecli] Created {zip_file}")
+    return result
+
+
+def cli(argv: Sequence[str] | None = None) -> int:
+    """Command-line interface backing the ``usecli-bundle`` console script.
+
+    So a project's pyproject.toml never needs to carry PyInstaller flags —
+    ``uv run usecli-bundle`` auto-detects the config and builds the bundle::
+
+        [tool.poe.tasks]
+        bundle = "uv run usecli-bundle"            # single-file executable
+        bundle-dir = "uv run usecli-bundle --mode onedir"
+    """
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        prog="usecli-bundle",
+        description="Build an executable bundle for the current usecli project.",
+    )
+    parser.add_argument(
+        "config_path",
+        nargs="?",
+        default=None,
+        help="Path to usecli.config.toml (auto-detected when omitted).",
+    )
+    parser.add_argument("--name", default=None, help="Executable name override.")
+    parser.add_argument(
+        "--mode",
+        choices=sorted(_MODE_FLAG),
+        default="onefile",
+        help="onefile (single executable, default) or onedir (folder bundle).",
+    )
+    parser.add_argument("--distpath", default=None, help="Output directory.")
+    parser.add_argument("--workpath", default=None, help="PyInstaller work dir.")
+    parser.add_argument(
+        "--zip",
+        action="store_true",
+        help="Zip the one-folder bundle into <name>.zip (onedir mode).",
+    )
+    known, extra = parser.parse_known_args(argv)
+    return pyinstaller(
+        config_path=known.config_path,
+        name=known.name,
+        mode=known.mode,
+        distpath=known.distpath,
+        workpath=known.workpath,
+        extra_args=extra or None,
+        zip=known.zip,
+    )
+
+
+if __name__ == "__main__":  # pragma: no cover - convenience CLI
+    sys.exit(cli())

usecli-0.1.79/src/usecli/bundler/__main__.py

@@ -0,0 +1,6 @@
+"""Allow ``python -m usecli.bundler`` to build a single-file executable."""
+
+from usecli.bundler import cli
+
+if __name__ == "__main__":
+    raise SystemExit(cli())