lib-cli-exit-tools 2.0.0__tar.gz → 2.1.0__tar.gz

{lib_cli_exit_tools-2.0.0 → lib_cli_exit_tools-2.1.0}/AGENTS.md

@@ -50,8 +50,8 @@ when writing or refracturing Python scripts, apply those Rules :
 ### Versioning & Releases
 
 - Single source of truth for the package version is `pyproject.toml` (`[project].version`).
-- Runtime code reads metadata via `importlib.metadata`; do not duplicate the version in code files.
-- On a version bump, update only `pyproject.toml` and the `CHANGELOG.md` entry; runtime code should continue to read the version via `importlib.metadata` (no separate `__init__conf__` file).
+- Automation rewrites `src/lib_cli_exit_tools/__init__conf__.py` from `pyproject.toml`, so runtime code imports generated constants instead of querying `importlib.metadata`.
+- After updating project metadata (version, summary, URLs, authors) run `make test` (or `python -m scripts.test`) to regenerate the metadata module before committing.
 - Tag releases `vX.Y.Z` and push tags; CI will build artifacts and publish when configured.
 
 ### Common Make Targets (Alphabetical)

{lib_cli_exit_tools-2.0.0 → lib_cli_exit_tools-2.1.0}/CHANGELOG.md

@@ -3,6 +3,13 @@
 All notable changes to this project are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 
+## [2.1.0] - 2025-10-13
+
+### Changed
+- `scripts.build` now calls `sync_metadata_module()` before invoking `python -m build`, ensuring wheels and sdists ship freshly generated metadata.
+- Added an explicit CLI test covering the `--version` flag so console-script aliases stay aligned with generated constants.
+- Updated README, INSTALL instructions, and the Quickstart notebook to document `lib-cli-exit-tools` as the canonical console entry point alongside its aliases.
+
 ## [2.0.0] - 2025-10-12
 
 ### Changed

{lib_cli_exit_tools-2.0.0 → lib_cli_exit_tools-2.1.0}/DEVELOPMENT.md

@@ -118,10 +118,10 @@ keep the signal-handling guarantees honest.
 
 ## Versioning & Metadata
 
-- Single source of truth for package metadata is `pyproject.toml` (`[project]`).
-- The library reads its own installed metadata at runtime via `importlib.metadata` (see `src/lib_cli_exit_tools/__init__conf__.py`).
-- Do not duplicate the version in code; bump only `pyproject.toml` and update `CHANGELOG.md`.
-- Console script name is discovered from entry points; defaults to `lib_cli_exit_tools`.
+- `pyproject.toml` (`[project]`) remains the single source of truth for name, version, homepage, and authors.
+- `scripts._utils.sync_metadata_module()` rewrites `src/lib_cli_exit_tools/__init__conf__.py` so runtime code consumes generated constants instead of `importlib.metadata`.
+- After editing project metadata (name, version, description, URLs, authors), run `make test` or `python -m scripts.test` to regenerate the module before committing.
+- Console script name is still discovered from entry points; automation falls back to `lib_cli_exit_tools` when no explicit alias exists.
 
 ## CI & Publishing
 

{lib_cli_exit_tools-2.0.0 → lib_cli_exit_tools-2.1.0}/INSTALL.md

@@ -85,7 +85,7 @@ pipx install "git+https://github.com/bitranox/lib_cli_exit_tools@vX.Y.Z"
 ```bash
 uv pip install -e .[dev]
 uv tool install lib_cli_exit_tools
-uvx lib_cli_exit_tools --help
+uvx lib-cli-exit-tools --help  # aliases: cli-exit-tools, lib_cli_exit_tools
 ```
 
 ### Installing from local artifacts
@@ -153,7 +153,7 @@ error: externally-managed-environment
 
 ### Missing command on PATH
 
-If `lib_cli_exit_tools --help` returns “command not found”, confirm that the installation location is on PATH. The most common fix is adding `~/.local/bin` (POSIX) or `%APPDATA%\Python\PythonXY\Scripts` (Windows) to your PATH environment variable, then re-opening the shell.
+If `lib-cli-exit-tools --help` (or the aliases `cli-exit-tools` / `lib_cli_exit_tools`) returns “command not found”, confirm that the installation location is on PATH. The most common fix is adding `~/.local/bin` (POSIX) or `%APPDATA%\Python\PythonXY\Scripts` (Windows) to your PATH environment variable, then re-opening the shell.
 
 ### Colour output not appearing
 

{lib_cli_exit_tools-2.0.0 → lib_cli_exit_tools-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lib_cli_exit_tools
-Version: 2.0.0
+Version: 2.1.0
 Summary: CLI exit handling helpers: clean signals, exit codes, and error printing
 Project-URL: Homepage, https://github.com/bitranox/lib_cli_exit_tools
 Project-URL: Repository, https://github.com/bitranox/lib_cli_exit_tools.git
@@ -65,14 +65,14 @@ See [INSTALL.md](INSTALL.md) for editable installs, pipx/uv usage, and troublesh
 
 ## Usage
 
-Console script:
+Console script (all commands map to ``lib_cli_exit_tools.cli:main``):
 
 ```bash
 # After install (pip/pipx/uv tool)
-lib_cli_exit_tools --help
-cli-exit-tools --help  # alias
-lib_cli_exit_tools info
-lib_cli_exit_tools fail  # intentionally trigger RuntimeError to test error paths
+lib-cli-exit-tools --help
+lib-cli-exit-tools info
+lib-cli-exit-tools fail  # intentionally trigger RuntimeError to test error paths
+# Aliases are also generated: `cli-exit-tools`, `lib_cli_exit_tools`
 ```
 
 ### Examples
@@ -280,9 +280,10 @@ except Exception as e:
     raise SystemExit(code)
 ```
 
-Command names registered on install
-- lib_cli_exit_tools (default)
+Command names registered on install (all invoke ``lib_cli_exit_tools.cli:main``)
+- lib-cli-exit-tools (default console script)
 - cli-exit-tools (alias)
+- lib_cli_exit_tools (alias)
 - python -m lib_cli_exit_tools (module entry)
 
 If you installed with --user or in a venv, make sure the corresponding bin directory is on PATH:
@@ -562,7 +563,7 @@ def main(argv: Sequence[str] | None = None) -> int:
     )
 ```
 
-When installed, the generated console scripts (`lib_cli_exit_tools`, `cli-exit-tools`, `lib-cli-exit-tools`) will import `your_package.cli:main`, and `python -m your_package` will follow the same code path via `__main__.py`.
+When installed, the generated console scripts (`lib-cli-exit-tools`, `cli-exit-tools`, `lib_cli_exit_tools`) will import `your_package.cli:main`, and `python -m your_package` will follow the same code path via `__main__.py`.
 
 ## Exit Codes
 

{lib_cli_exit_tools-2.0.0 → lib_cli_exit_tools-2.1.0}/README.md

@@ -29,14 +29,14 @@ See [INSTALL.md](INSTALL.md) for editable installs, pipx/uv usage, and troublesh
 
 ## Usage
 
-Console script:
+Console script (all commands map to ``lib_cli_exit_tools.cli:main``):
 
 ```bash
 # After install (pip/pipx/uv tool)
-lib_cli_exit_tools --help
-cli-exit-tools --help  # alias
-lib_cli_exit_tools info
-lib_cli_exit_tools fail  # intentionally trigger RuntimeError to test error paths
+lib-cli-exit-tools --help
+lib-cli-exit-tools info
+lib-cli-exit-tools fail  # intentionally trigger RuntimeError to test error paths
+# Aliases are also generated: `cli-exit-tools`, `lib_cli_exit_tools`
 ```
 
 ### Examples
@@ -244,9 +244,10 @@ except Exception as e:
     raise SystemExit(code)
 ```
 
-Command names registered on install
-- lib_cli_exit_tools (default)
+Command names registered on install (all invoke ``lib_cli_exit_tools.cli:main``)
+- lib-cli-exit-tools (default console script)
 - cli-exit-tools (alias)
+- lib_cli_exit_tools (alias)
 - python -m lib_cli_exit_tools (module entry)
 
 If you installed with --user or in a venv, make sure the corresponding bin directory is on PATH:
@@ -526,7 +527,7 @@ def main(argv: Sequence[str] | None = None) -> int:
     )
 ```
 
-When installed, the generated console scripts (`lib_cli_exit_tools`, `cli-exit-tools`, `lib-cli-exit-tools`) will import `your_package.cli:main`, and `python -m your_package` will follow the same code path via `__main__.py`.
+When installed, the generated console scripts (`lib-cli-exit-tools`, `cli-exit-tools`, `lib_cli_exit_tools`) will import `your_package.cli:main`, and `python -m your_package` will follow the same code path via `__main__.py`.
 
 ## Exit Codes
 

{lib_cli_exit_tools-2.0.0 → lib_cli_exit_tools-2.1.0}/docs/system-design/module_reference.md

@@ -38,7 +38,7 @@ Downstream CLIs and automation pipelines need deterministic exit codes, signal h
 * Split runtime responsibilities into well-documented modules (`core`, `application`, `adapters`, `cli`) that mirror clean-architecture prompts.
 * Provide a lightweight metadata façade (`__init__conf__.py`) so CLI commands expose provenance without heavy packaging dependencies.
 * Funnel all exit handling through `application.runner` and `core.exit_codes`, documenting each resolver path and configuration hook.
-* Publish behaviour-driven tests that read like specifications and explicitly cover CLI surfaces, metadata fallbacks, module entry balance, and automation scripts.
+* Publish behaviour-driven tests that read like specifications and explicitly cover CLI surfaces, metadata exports, module entry balance, and automation scripts.
 * Align system documentation with inline docstrings and testing strategy to create a single source of truth for maintainers.
 
 ---
@@ -56,7 +56,7 @@ Downstream CLIs and automation pipelines need deterministic exit codes, signal h
 5. `core.exit_codes` resolves exit codes via ordered strategies (subprocess return codes, signals, errno/winerror, sysexits, platform tables).
 6. `__init__conf__.py` supplies metadata for `info` commands and documentation output.
 
-**System Dependencies:** Standard library (`signal`, `sys`, `subprocess`, `importlib.metadata`, `contextlib`, `dataclasses`), `click`, `rich`, `rich-click`.
+**System Dependencies:** Standard library (`signal`, `sys`, `subprocess`, `contextlib`, `dataclasses`), `click`, `rich`, `rich-click`.
 
 ---
 
@@ -78,9 +78,9 @@ Downstream CLIs and automation pipelines need deterministic exit codes, signal h
 
 ### Module: lib_cli_exit_tools/__init__conf__.py
 
-* **Purpose:** Provide metadata helpers and `print_info()` for CLI provenance.
-* **Input:** Distribution metadata via `importlib.metadata`; fallback defaults.
-* **Output:** Constants (`name`, `title`, `version`, `homepage`, `author`, `shell_command`) and metadata helpers (`_meta`, `_version`, `_home_page`, `_author`, `_summary`).
+* **Purpose:** Publish static metadata constants and `print_info()` for CLI provenance.
+* **Input:** Generated from `pyproject.toml` by `scripts._utils.sync_metadata_module`; no runtime metadata lookups.
+* **Output:** Constants (`name`, `title`, `version`, `homepage`, `author`, `author_email`, `shell_command`) and the formatted `print_info()` helper.
 * **Location:** `src/lib_cli_exit_tools/__init__conf__.py`
 
 ### Module: lib_cli_exit_tools/core/configuration.py

{lib_cli_exit_tools-2.0.0 → lib_cli_exit_tools-2.1.0}/notebooks/Quickstart.ipynb

@@ -70,7 +70,7 @@
    "outputs": [],
    "source": [
     "!lib_cli_exit_tools --version\n",
-    "!lib_cli_exit_tools --help\n",
+    "!lib-cli-exit-tools --help\n",
     "!lib_cli_exit_tools info"
    ]
   },

{lib_cli_exit_tools-2.0.0 → lib_cli_exit_tools-2.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "lib_cli_exit_tools"
-version = "2.0.0"
+version = "2.1.0"
 description = "CLI exit handling helpers: clean signals, exit codes, and error printing"
 readme = "README.md"
 requires-python = ">=3.13"

{lib_cli_exit_tools-2.0.0 → lib_cli_exit_tools-2.1.0}/scripts/_utils.py

@@ -4,7 +4,7 @@ Purpose
 -------
 Collect helper functions used by the ``scripts/`` entry points (build, test,
 release) so git helpers and subprocess wrappers live in one place. The behaviour mirrors the operational guidance described in
-``docs/systemdesign/concept_architecture_plan.md`` and ``DEVELOPMENT.md``.
+``docs/systemdesign/module_reference.md`` and ``DEVELOPMENT.md``.
 
 Contents
 --------
@@ -21,12 +21,15 @@ avoid duplication and keep CI/CD behaviour consistent with documentation.
 
 from __future__ import annotations
 
+import json
 import os
 import re
 import shlex
+import shutil
 import subprocess
 import sys
 import tomllib
+import textwrap
 from dataclasses import dataclass
 from pathlib import Path
 from subprocess import CompletedProcess
@@ -54,6 +57,12 @@ class ProjectMetadata:
     import_package: str
     coverage_source: str
     scripts: dict[str, str]
+    metadata_module: Path
+    version: str
+    summary: str
+    author_name: str
+    author_email: str
+    shell_command: str
 
     def github_tarball_url(self, version: str) -> str:
         if self.repo_host == "github.com" and self.repo_owner and self.repo_name:
@@ -90,6 +99,7 @@ class ProjectMetadata:
             summary.append(f"repository={self.repo_url}")
         if self.homepage:
             summary.append(f"homepage={self.homepage}")
+        summary.append(f"version={self.version}")
         return tuple(summary)
 
 
@@ -131,14 +141,7 @@ def run(
 
 
 def cmd_exists(name: str) -> bool:
-    return (
-        subprocess.call(
-            ["bash", "-lc", f"command -v {shlex.quote(name)} >/dev/null 2>&1"],
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.DEVNULL,
-        )
-        == 0
-    )
+    return shutil.which(name) is not None
 
 
 def _normalize_slug(value: str) -> str:
@@ -313,6 +316,47 @@ def get_project_metadata(pyproject: Path = Path("pyproject.toml")) -> ProjectMet
     coverage_source = _derive_coverage_source(data, import_package)
     scripts = _derive_scripts(data)
 
+    version = read_version_from_pyproject(pyproject)
+    summary = description.strip() if description else ""
+    if not summary:
+        summary_candidate = project_table.get("summary")
+        summary = summary_candidate.strip() if isinstance(summary_candidate, str) else ""
+    if not summary:
+        summary = name
+
+    author_name = ""
+    author_email = ""
+    authors_value = project_table.get("authors")
+    if isinstance(authors_value, list):
+        authors_list = cast(list[object], authors_value)
+        for author_entry in authors_list:
+            if not isinstance(author_entry, dict):
+                continue
+            author_dict = cast(dict[str, object], author_entry)
+            name_field = author_dict.get("name")
+            email_field = author_dict.get("email")
+            if not author_name and isinstance(name_field, str) and name_field.strip():
+                author_name = name_field.strip()
+            if not author_email and isinstance(email_field, str) and email_field.strip():
+                author_email = email_field.strip()
+    if not author_name:
+        author_name = repo_owner or name
+
+    shell_command = slug.replace("_", "-")
+    preferred_entry = _select_cli_entry(
+        scripts,
+        (
+            slug,
+            name,
+            import_package,
+            import_package.replace("_", "-"),
+        ),
+    )
+    if preferred_entry is not None:
+        shell_command = preferred_entry[0]
+
+    metadata_module = (Path("src") / import_package / "__init__conf__.py").resolve()
+
     meta = ProjectMetadata(
         name=name,
         description=description,
@@ -325,11 +369,109 @@ def get_project_metadata(pyproject: Path = Path("pyproject.toml")) -> ProjectMet
         import_package=import_package,
         coverage_source=coverage_source,
         scripts=scripts,
+        metadata_module=metadata_module,
+        version=version,
+        summary=summary,
+        author_name=author_name,
+        author_email=author_email,
+        shell_command=shell_command,
     )
     _METADATA_CACHE[path] = meta
     return meta
 
 
+def _quote(value: str) -> str:
+    return json.dumps(value, ensure_ascii=False)
+
+
+def _render_metadata_module(project: ProjectMetadata) -> str:
+    homepage = project.homepage or project.repo_url or ""
+    body = f'''"""Static package metadata surfaced to CLI commands and documentation.
+
+Purpose
+-------
+Expose the current project metadata as simple constants. These values are kept
+in sync with ``pyproject.toml`` by development automation (tests, push
+pipelines), so runtime code does not query packaging metadata.
+
+Contents
+--------
+* Module-level constants describing the published package.
+* :func:`print_info` rendering the constants for the CLI ``info`` command.
+
+System Role
+-----------
+Lives in the adapters/platform layer; CLI transports import these constants to
+present authoritative project information without invoking packaging APIs.
+"""
+
+from __future__ import annotations
+
+#: Distribution name declared in ``pyproject.toml``.
+name = {_quote(project.name)}
+#: Human-readable summary shown in CLI help output.
+title = {_quote(project.summary)}
+#: Current release version pulled from ``pyproject.toml`` by automation.
+version = {_quote(project.version)}
+#: Repository homepage presented to users.
+homepage = {_quote(homepage)}
+#: Author attribution surfaced in CLI output.
+author = {_quote(project.author_name)}
+#: Contact email surfaced in CLI output.
+author_email = {_quote(project.author_email)}
+#: Console-script name published by the package.
+shell_command = {_quote(project.shell_command)}
+
+
+def print_info() -> None:
+    """Print the summarised metadata block used by the CLI ``info`` command.
+
+    Why
+        Provides a single, auditable rendering function so documentation and
+        CLI output always match the system design reference.
+
+    Side Effects
+        Writes to ``stdout``.
+
+    Examples
+    --------
+    >>> print_info()  # doctest: +ELLIPSIS
+    Info for {project.name}:
+    ...
+    """
+
+    fields = [
+        ("name", name),
+        ("title", title),
+        ("version", version),
+        ("homepage", homepage),
+        ("author", author),
+        ("author_email", author_email),
+        ("shell_command", shell_command),
+    ]
+    pad = max(len(label) for label, _ in fields)
+    lines = [f"Info for {{name}}:", ""]
+    lines.extend(f"    {{label.ljust(pad)}} = {{value}}" for label, value in fields)
+    print("\\n".join(lines))
+'''
+    return textwrap.dedent(body)
+
+
+def sync_metadata_module(project: ProjectMetadata) -> None:
+    """Write ``__init__conf__.py`` so the constants mirror ``pyproject.toml``."""
+
+    content = _render_metadata_module(project)
+    module_path = project.metadata_module
+    module_path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        existing = module_path.read_text(encoding="utf-8")
+    except FileNotFoundError:
+        existing = ""
+    if existing == content:
+        return
+    module_path.write_text(content, encoding="utf-8")
+
+
 def read_version_from_pyproject(pyproject: Path = Path("pyproject.toml")) -> str:
     data = _load_pyproject(pyproject)
     project_table = _as_str_mapping(data.get("project"))

{lib_cli_exit_tools-2.0.0 → lib_cli_exit_tools-2.1.0}/scripts/build.py

@@ -4,7 +4,7 @@ import sys
 
 import rich_click as click
 
-from ._utils import get_project_metadata, run
+from ._utils import get_project_metadata, run, sync_metadata_module
 
 __all__ = ["build_artifacts"]
 
@@ -22,6 +22,7 @@ def _failure(label: str) -> str:
 def build_artifacts() -> None:
     """Build Python wheel and sdist artifacts."""
 
+    sync_metadata_module(PROJECT)
     click.echo("[build] Building wheel/sdist via python -m build")
     build_result = run(["python", "-m", "build"], check=False, capture=False)
     click.echo(f"[build] {_status('success') if build_result.code == 0 else _failure('failed')}")

{lib_cli_exit_tools-2.0.0 → lib_cli_exit_tools-2.1.0}/scripts/push.py

@@ -6,7 +6,13 @@ from pathlib import Path
 
 import rich_click as click
 
-from ._utils import get_project_metadata, git_branch, read_version_from_pyproject, run
+from ._utils import (
+    get_project_metadata,
+    git_branch,
+    read_version_from_pyproject,
+    run,
+    sync_metadata_module,
+)
 
 __all__ = ["push"]
 
@@ -15,6 +21,7 @@ def push(*, remote: str = "origin", message: str | None = None) -> None:
     """Run checks, commit changes, and push the current branch."""
 
     metadata = get_project_metadata()
+    sync_metadata_module(metadata)
     version = read_version_from_pyproject(Path("pyproject.toml")) or "unknown"
     click.echo("[push] project diagnostics: " + ", ".join(metadata.diagnostic_lines()))
     click.echo(f"[push] version={version}")

{lib_cli_exit_tools-2.0.0 → lib_cli_exit_tools-2.1.0}/scripts/test.py

@@ -7,7 +7,7 @@ import shutil
 import subprocess
 import sys
 import tempfile
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
 from pathlib import Path
 from types import ModuleType
 from typing import cast
@@ -19,6 +19,7 @@ from ._utils import (
     bootstrap_dev,
     get_project_metadata,
     run,
+    sync_metadata_module,
 )
 
 PROJECT = get_project_metadata()
@@ -51,6 +52,7 @@ def _refresh_default_env() -> None:
 def run_coverage(*, verbose: bool = False) -> None:
     """Run pytest under coverage using python modules to avoid PATH shim issues."""
 
+    sync_metadata_module(PROJECT)
     bootstrap_dev()
     _prune_coverage_data_files()
     _remove_report_artifacts()
@@ -95,23 +97,16 @@ def _resolve_pip_audit_ignores() -> list[str]:
 def _extract_audit_dependencies(payload: object) -> _AuditPayload:
     """Normalise `pip-audit --format json` output into dictionaries."""
 
-    dependencies: _AuditPayload = []
-    candidate_iter: list[object] = []
-    if isinstance(payload, dict):
-        payload_dict = cast(dict[str, object], payload)
-        raw_candidates = payload_dict.get("dependencies", [])
-        if isinstance(raw_candidates, list):
-            candidate_iter = list(cast(list[object], raw_candidates))
-    elif isinstance(payload, list):  # pragma: no cover - legacy output
-        candidate_iter = list(cast(list[object], payload))
-    else:  # pragma: no cover - defensive
-        return dependencies
+    if not isinstance(payload, dict):
+        return []
 
-    for candidate in candidate_iter:
-        if isinstance(candidate, dict):
-            dependencies.append(cast(dict[str, object], candidate))
+    payload_dict = cast(dict[str, object], payload)
+    raw_candidates = payload_dict.get("dependencies", [])
+    if not isinstance(raw_candidates, list):
+        return []
 
-    return dependencies
+    candidate_list = cast(list[object], raw_candidates)
+    return [cast(dict[str, object], candidate) for candidate in candidate_list if isinstance(candidate, dict)]
 
 
 def run_tests(*, coverage: str = "on", verbose: bool = False, strict_format: bool | None = None) -> None:
@@ -119,8 +114,10 @@ def run_tests(*, coverage: str = "on", verbose: bool = False, strict_format: boo
     if not verbose and env_verbose in _TRUTHY:
         verbose = True
 
+    sync_metadata_module(PROJECT)
+
     def _run(
-        cmd: list[str] | str,
+        cmd: Sequence[str] | str,
         *,
         env: dict[str, str] | None = None,
         check: bool = True,
@@ -138,7 +135,7 @@ def run_tests(*, coverage: str = "on", verbose: bool = False, strict_format: boo
                     env_view = " ".join(f"{k}={v}" for k, v in overrides.items())
                     click.echo(f"    env {env_view}")
         merged_env = _default_env if env is None else _default_env | env
-        result = run(cmd, env=merged_env, check=False, capture=capture)  # type: ignore[arg-type]
+        result = run(cmd, env=merged_env, check=False, capture=capture)
         if verbose and label:
             click.echo(f"    -> {label}: exit={result.code} out={bool(result.out)} err={bool(result.err)}")
 
@@ -292,11 +289,8 @@ def run_tests(*, coverage: str = "on", verbose: bool = False, strict_format: boo
     )
 
     def _run_pytest() -> None:
-        for f in (".coverage", "coverage.xml"):
-            try:
-                Path(f).unlink()
-            except FileNotFoundError:
-                pass
+        for path in (Path(".coverage"), Path("coverage.xml")):
+            path.unlink(missing_ok=True)
 
         if coverage == "on" or (coverage == "auto" and (os.getenv("CI") or os.getenv("CODECOV_TOKEN"))):
             click.echo("[coverage] enabled")

lib_cli_exit_tools-2.1.0/src/lib_cli_exit_tools/__init__conf__.py

@@ -0,0 +1,67 @@
+"""Static package metadata surfaced to CLI commands and documentation.
+
+Purpose
+-------
+Expose the current project metadata as simple constants. These values are kept
+in sync with ``pyproject.toml`` by development automation (tests, push
+pipelines), so runtime code does not query packaging metadata.
+
+Contents
+--------
+* Module-level constants describing the published package.
+* :func:`print_info` rendering the constants for the CLI ``info`` command.
+
+System Role
+-----------
+Lives in the adapters/platform layer; CLI transports import these constants to
+present authoritative project information without invoking packaging APIs.
+"""
+
+from __future__ import annotations
+
+#: Distribution name declared in ``pyproject.toml``.
+name = "lib_cli_exit_tools"
+#: Human-readable summary shown in CLI help output.
+title = "CLI exit handling helpers: clean signals, exit codes, and error printing"
+#: Current release version pulled from ``pyproject.toml`` by automation.
+version = "2.1.0"
+#: Repository homepage presented to users.
+homepage = "https://github.com/bitranox/lib_cli_exit_tools"
+#: Author attribution surfaced in CLI output.
+author = "bitranox"
+#: Contact email surfaced in CLI output.
+author_email = "bitranox@gmail.com"
+#: Console-script name published by the package.
+shell_command = "lib-cli-exit-tools"
+
+
+def print_info() -> None:
+    """Print the summarised metadata block used by the CLI ``info`` command.
+
+    Why
+        Provides a single, auditable rendering function so documentation and
+        CLI output always match the system design reference.
+
+    Side Effects
+        Writes to ``stdout``.
+
+    Examples
+    --------
+    >>> print_info()  # doctest: +ELLIPSIS
+    Info for lib_cli_exit_tools:
+    ...
+    """
+
+    fields = [
+        ("name", name),
+        ("title", title),
+        ("version", version),
+        ("homepage", homepage),
+        ("author", author),
+        ("author_email", author_email),
+        ("shell_command", shell_command),
+    ]
+    pad = max(len(label) for label, _ in fields)
+    lines = [f"Info for {name}:", ""]
+    lines.extend(f"    {label.ljust(pad)} = {value}" for label, value in fields)
+    print("\n".join(lines))

{lib_cli_exit_tools-2.0.0 → lib_cli_exit_tools-2.1.0}/src/lib_cli_exit_tools/cli.py

@@ -136,7 +136,7 @@ def _store_traceback_flag(ctx: click.Context, traceback: bool) -> None:
 
 @cli.command("info", context_settings=CLICK_CONTEXT_SETTINGS)
 def cli_info() -> None:
-    """Display package metadata sourced from :mod:`importlib.metadata`.
+    """Display package metadata exported by :mod:`lib_cli_exit_tools.__init__conf__`.
 
     Why:
         Offer a zero-dependency way for users to confirm the installed version

{lib_cli_exit_tools-2.0.0 → lib_cli_exit_tools-2.1.0}/tests/test_cli.py

@@ -75,6 +75,18 @@ def test_when_info_is_invoked_metadata_is_displayed(cli_runner: CliRunner, strip
         assert field in plain_output
 
 
+@pytest.mark.os_agnostic
+def test_when_version_flag_is_used_metadata_banner_is_returned(
+    cli_runner: CliRunner,
+    strip_ansi: Callable[[str], str],
+) -> None:
+    result: Result = cli_runner.invoke(cli_mod.cli, ["--version"])
+    plain_output = strip_ansi(result.output).strip()
+
+    assert result.exit_code == 0
+    assert plain_output == f"{metadata.shell_command} version {metadata.version}"
+
+
 @pytest.mark.os_agnostic
 def test_when_fail_is_invoked_a_runtime_error_surfaces(cli_runner: CliRunner) -> None:
     result: Result = cli_runner.invoke(cli_mod.cli, ["fail"])

lib_cli_exit_tools-2.1.0/tests/test_metadata.py

@@ -0,0 +1,47 @@
+"""Metadata stories ensuring generated constants stay authoritative."""
+
+from __future__ import annotations
+
+import pytest
+
+from lib_cli_exit_tools import __init__conf__ as metadata
+from scripts import _utils
+
+
+@pytest.mark.os_agnostic
+def test_when_print_info_runs_it_lists_every_field(capsys: pytest.CaptureFixture[str]) -> None:
+    metadata.print_info()
+
+    captured = capsys.readouterr().out.splitlines()
+    banner, *detail_lines = [line.strip() for line in captured if line.strip()]
+    assert banner == f"Info for {metadata.name}:"
+
+    rows = {}
+    for line in detail_lines:
+        if " = " not in line:
+            continue
+        label, value = line.split(" = ", 1)
+        rows[label.strip()] = value.strip()
+
+    assert rows == {
+        "name": metadata.name,
+        "title": metadata.title,
+        "version": metadata.version,
+        "homepage": metadata.homepage,
+        "author": metadata.author,
+        "author_email": metadata.author_email,
+        "shell_command": metadata.shell_command,
+    }
+
+
+@pytest.mark.os_agnostic
+def test_metadata_constants_match_pyproject() -> None:
+    project = _utils.get_project_metadata()
+
+    assert metadata.name == project.name
+    assert metadata.title == project.summary
+    assert metadata.version == project.version
+    assert metadata.homepage == project.homepage or project.repo_url or ""
+    assert metadata.author == project.author_name
+    assert metadata.author_email == project.author_email
+    assert metadata.shell_command == project.shell_command

lib_cli_exit_tools-2.0.0/src/lib_cli_exit_tools/__init__conf__.py

@@ -1,220 +0,0 @@
-"""Metadata facade that keeps CLI help/version text aligned with packaging data.
-
-Purpose:
-    Expose read-only metadata helpers the CLI can use without importing heavy
-    packaging libraries.
-Contents:
-    * Metadata lookup helpers prefixed with ``_`` to cache and normalise states.
-    * Public constants (`name`, `title`, `version`, etc.) derived from metadata.
-    * :func:`print_info` for human-friendly provenance output.
-System Integration:
-    Read by :mod:`lib_cli_exit_tools.cli` and documented in
-    ``docs/system-design/module_reference.md`` so CLI output matches project
-    release metadata.
-"""
-
-from __future__ import annotations
-
-from functools import cache
-from importlib import metadata as _im
-from importlib.metadata import PackageMetadata
-
-#: Distribution identifier used for importlib.metadata lookups. Mirrors the
-#: project name declared in ``pyproject.toml`` so metadata resolution stays in
-#: sync with packaging configuration.
-_DIST_NAME = "lib_cli_exit_tools"
-
-
-def _get_str(meta: PackageMetadata | None, key: str, default: str = "") -> str:
-    """Why:
-        Normalise metadata lookups so CLI output stays predictable.
-    What:
-        Fetch the string value for ``key`` from ``meta`` or fall back to
-        ``default`` when the entry is missing or not a plain string.
-    Parameters:
-        meta: Metadata mapping for the installed distribution, or ``None``
-            when running from source.
-        key: Field name to fetch (e.g. ``"Summary"``).
-        default: Fallback string when the key is absent or unsuitable.
-    Returns:
-        The resolved string value to display in CLI output.
-    Side Effects:
-        None.
-    """
-    if meta is None:
-        return default
-    value = meta.get(key)
-    return value if isinstance(value, str) else default
-
-
-def _meta() -> PackageMetadata | None:
-    """Why:
-        Provide a single location that tolerates missing installations.
-    What:
-        Attempt to read the distribution metadata via ``importlib.metadata``.
-    Parameters:
-        None.
-    Returns:
-        Metadata mapping when available, otherwise ``None``.
-    Side Effects:
-        None.
-    """
-    try:
-        meta: PackageMetadata = _im.metadata(_DIST_NAME)
-        return meta
-    except _im.PackageNotFoundError:
-        return None
-
-
-def _version() -> str:
-    """Why:
-        Surface the installed version for CLI flags and documentation.
-    What:
-        Retrieve the distribution version, falling back to a development label
-        when metadata is unavailable.
-    Parameters:
-        None.
-    Returns:
-        Semantic-version string.
-    Side Effects:
-        None.
-    Examples:
-        >>> isinstance(_version(), str)
-        True
-    """
-    try:
-        return _im.version(_DIST_NAME)
-    except _im.PackageNotFoundError:
-        return "0.0.0.dev0"
-
-
-def _home_page(meta: PackageMetadata | None) -> str:
-    """Why:
-        Normalise homepage lookups across build backends.
-    What:
-        Return the documented project homepage, favouring metadata values but
-        defaulting to GitHub when absent.
-    Parameters:
-        meta: Metadata mapping or ``None`` when unavailable.
-    Returns:
-        Homepage URL string.
-    Side Effects:
-        None.
-    """
-    if meta is None:
-        return "https://github.com/bitranox/lib_cli_exit_tools"
-    primary = _get_str(meta, "Home-page")
-    fallback = _get_str(meta, "Homepage")
-    return primary or fallback or "https://github.com/bitranox/lib_cli_exit_tools"
-
-
-def _author(meta: PackageMetadata | None) -> tuple[str, str]:
-    """Why:
-        Ensure provenance output always includes a name and contact address.
-    What:
-        Extract the author name and email from metadata, applying defaults.
-    Parameters:
-        meta: Metadata mapping or ``None`` when unavailable.
-    Returns:
-        Tuple of ``(author_name, author_email)``.
-    Side Effects:
-        None.
-    """
-    if meta is None:
-        return ("bitranox", "bitranox@gmail.com")
-    return (
-        _get_str(meta, "Author", "bitranox"),
-        _get_str(meta, "Author-email", "bitranox@gmail.com"),
-    )
-
-
-def _summary(meta: PackageMetadata | None) -> str:
-    """Why:
-        Guarantee a descriptive summary in CLI output even when metadata is sparse.
-    What:
-        Return the ``Summary`` field or a human-readable default.
-    Parameters:
-        meta: Metadata mapping or ``None`` when missing.
-    Returns:
-        Summary string.
-    Side Effects:
-        None.
-    """
-    return _get_str(meta, "Summary", "Functions to exit a CLI application properly")
-
-
-@cache
-def _shell_command() -> str:
-    """Why:
-        Surface the console-script name so documentation matches installation.
-    What:
-        Inspect entry points for the target referencing ``cli:main`` and return
-        its advertised name.
-    Parameters:
-        None.
-    Returns:
-        Console-script name or the distribution identifier when unresolved.
-    Side Effects:
-        None.
-    Examples:
-        >>> isinstance(_shell_command(), str)
-        True
-    """
-    # Discover console script name mapping to our CLI main, fallback to dist name
-    entries = _im.entry_points(group="console_scripts")
-    target = "lib_cli_exit_tools.cli:main"
-    for entry in entries:
-        if entry.value == target:
-            return entry.name
-    return _DIST_NAME
-
-
-# Public values (resolve metadata once)
-#: Cached metadata mapping to avoid repeated importlib lookups.
-_m = _meta()
-#: Distribution name used when metadata lookups fail.
-name = _DIST_NAME
-#: Human-readable project title displayed in CLI help.
-title = _summary(_m)
-#: Installed package version string surfaced via --version.
-version = _version()
-#: Project homepage for documentation and issue reporting.
-homepage = _home_page(_m)
-#: Primary author details used in info output.
-author, author_email = _author(_m)
-#: Console script entry point that launches this CLI.
-shell_command = _shell_command()
-
-
-def print_info() -> None:
-    """Why:
-        Offer operators a quick snapshot of build provenance and support links.
-    What:
-        Emit a formatted block containing metadata derived from this module.
-    Parameters:
-        None.
-    Returns:
-        ``None``.
-    Side Effects:
-        Writes text to ``stdout``.
-    Examples:
-        >>> import contextlib, io
-        >>> buf = io.StringIO()
-        >>> with contextlib.redirect_stdout(buf):
-        ...     print_info()
-        >>> "Info for" in buf.getvalue()
-        True
-    """
-    fields = [
-        ("name", name),
-        ("title", title),
-        ("version", version),
-        ("homepage", homepage),
-        ("author", author),
-        ("author_email", author_email),
-        ("shell_command", shell_command),
-    ]
-    pad = max(len(k) for k, _ in fields)
-    lines = [f"Info for {name}:", ""]
-    lines += [f"    {k.ljust(pad)} = {v}" for k, v in fields]
-    print("\n".join(lines))

lib_cli_exit_tools-2.0.0/tests/test_metadata.py

@@ -1,101 +0,0 @@
-"""Metadata stories ensuring importlib fallbacks stay predictable."""
-
-from __future__ import annotations
-
-import importlib
-
-import pytest
-
-from lib_cli_exit_tools import __init__conf__ as metadata
-
-
-@pytest.mark.os_agnostic
-def test_when_print_info_runs_it_lists_every_field(capsys: pytest.CaptureFixture[str]) -> None:
-    metadata.print_info()
-
-    captured = capsys.readouterr().out
-
-    for label in ("name", "title", "version", "homepage", "author", "author_email", "shell_command"):
-        assert label in captured
-
-
-@pytest.mark.os_agnostic
-def test_when_distribution_is_missing_fallback_values_surface(
-    monkeypatch: pytest.MonkeyPatch,
-    capsys: pytest.CaptureFixture[str],
-) -> None:
-    class FailingLookup:
-        def __call__(self, _dist: str) -> None:
-            raise metadata._im.PackageNotFoundError  # type: ignore[attr-defined]
-
-    with monkeypatch.context() as ctx:
-        ctx.setattr(metadata._im, "metadata", FailingLookup())  # type: ignore[attr-defined]
-        ctx.setattr(metadata._im, "version", FailingLookup())  # type: ignore[attr-defined]
-        reloaded = importlib.reload(metadata)
-
-        reloaded.print_info()
-
-        captured = capsys.readouterr().out
-
-        assert "0.0.0.dev0" in captured
-        assert "lib_cli_exit_tools" in captured
-        assert "bitranox@gmail.com" in captured
-
-    importlib.reload(metadata)
-
-
-@pytest.mark.os_agnostic
-def test_when_shell_command_is_resolved_matching_entry_point_wins(monkeypatch: pytest.MonkeyPatch) -> None:
-    class EntryPoint:
-        def __init__(self, name: str, value: str) -> None:
-            self.name = name
-            self.value = value
-
-    def fake_entry_points(*, group: str) -> list[EntryPoint]:
-        assert group == "console_scripts"
-        return [
-            EntryPoint("alt-cli", "other.module:main"),
-            EntryPoint("lib-cli-exit-tools", "lib_cli_exit_tools.cli:main"),
-        ]
-
-    with monkeypatch.context() as ctx:
-        ctx.setattr(metadata._im, "entry_points", fake_entry_points)  # type: ignore[attr-defined]
-        reloaded = importlib.reload(metadata)
-
-        assert reloaded.shell_command == "lib-cli-exit-tools"
-
-    importlib.reload(metadata)
-
-
-@pytest.mark.os_agnostic
-def test_when_shell_command_has_no_match_the_distribution_name_is_used(monkeypatch: pytest.MonkeyPatch) -> None:
-    def fake_entry_points(*, group: str) -> list[object]:
-        assert group == "console_scripts"
-        return []
-
-    with monkeypatch.context() as ctx:
-        ctx.setattr(metadata._im, "entry_points", fake_entry_points)  # type: ignore[attr-defined]
-        reloaded = importlib.reload(metadata)
-        assert reloaded.shell_command == "lib_cli_exit_tools"
-
-    importlib.reload(metadata)
-
-
-@pytest.mark.os_agnostic
-def test_when_metadata_values_are_not_strings_defaults_apply(monkeypatch: pytest.MonkeyPatch) -> None:
-    class OddMeta:
-        def get(self, key: str, default: object | None = None) -> object:
-            return 123
-
-    def fake_metadata(_dist: str) -> OddMeta:
-        return OddMeta()
-
-    with monkeypatch.context() as ctx:
-        ctx.setattr(metadata._im, "metadata", fake_metadata)  # type: ignore[attr-defined]
-        reloaded = importlib.reload(metadata)
-
-        assert reloaded.author == "bitranox"
-        assert reloaded.author_email == "bitranox@gmail.com"
-        assert reloaded.title == "Functions to exit a CLI application properly"
-
-    importlib.reload(metadata)