elva-cli 0.0.2__tar.gz → 0.0.4__tar.gz

elva_cli-0.0.4/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.5
+Name: elva-cli
+Version: 0.0.4
+Summary: Elva - CLI for Theneo Elva
+Project-URL: Homepage, https://getelva.ai
+Project-URL: Source, https://github.com/Theneo-Inc/theneo-elva-cli
+Project-URL: Issues, https://github.com/Theneo-Inc/theneo-elva-cli/issues
+Author-email: Theneo <support@theneo.io>
+Keywords: api,cli,documentation,elva,openapi,theneo
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: platformdirs>=4.2
+Requires-Dist: typer<1.0,>=0.15
+Provides-Extra: dev
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pytest>=8.2; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Elva CLI
+
+Manage your [Elva](https://getelva.ai) API projects from the terminal: import specs,
+inspect collections, and generate MCP servers without opening a browser.
+
+> **Early alpha.** The command surface is still taking shape. This release ships
+> `--version` and `--help` only; the first working commands land in `0.1.0`.
+
+## Install
+
+Requires Python 3.11 or newer.
+
+```bash
+uv tool install elva-cli
+```
+
+Or with [pipx](https://pipx.pypa.io/), if you already use it:
+
+```bash
+pipx install elva-cli
+```
+
+Either way, `elva` is then available from any directory:
+
+```bash
+elva --version
+elva --help
+```
+
+To try it without installing anything:
+
+```bash
+uvx --from elva-cli elva --version
+```
+
+Don't have `uv`? It is a single command and no prerequisites:
+
+```bash
+curl -fsSL https://astral.sh/uv/install.sh | sh          # macOS, Linux
+powershell -c "irm https://astral.sh/uv/install.ps1|iex" # Windows
+```
+
+### Upgrade
+
+```bash
+uv tool upgrade elva-cli      # or: pipx upgrade elva-cli
+```
+
+## Requirements
+
+- Python 3.11 or newer (bundled automatically if you install via `uv tool`)
+- An [Elva](https://getelva.ai) account
+
+## Links
+
+- [Elva](https://getelva.ai)
+- [Issues](https://github.com/Theneo-Inc/theneo-elva-cli/issues)
+- [Contributing](CONTRIBUTING.md)

elva_cli-0.0.4/README.md

@@ -0,0 +1,58 @@
+# Elva CLI
+
+Manage your [Elva](https://getelva.ai) API projects from the terminal: import specs,
+inspect collections, and generate MCP servers without opening a browser.
+
+> **Early alpha.** The command surface is still taking shape. This release ships
+> `--version` and `--help` only; the first working commands land in `0.1.0`.
+
+## Install
+
+Requires Python 3.11 or newer.
+
+```bash
+uv tool install elva-cli
+```
+
+Or with [pipx](https://pipx.pypa.io/), if you already use it:
+
+```bash
+pipx install elva-cli
+```
+
+Either way, `elva` is then available from any directory:
+
+```bash
+elva --version
+elva --help
+```
+
+To try it without installing anything:
+
+```bash
+uvx --from elva-cli elva --version
+```
+
+Don't have `uv`? It is a single command and no prerequisites:
+
+```bash
+curl -fsSL https://astral.sh/uv/install.sh | sh          # macOS, Linux
+powershell -c "irm https://astral.sh/uv/install.ps1|iex" # Windows
+```
+
+### Upgrade
+
+```bash
+uv tool upgrade elva-cli      # or: pipx upgrade elva-cli
+```
+
+## Requirements
+
+- Python 3.11 or newer (bundled automatically if you install via `uv tool`)
+- An [Elva](https://getelva.ai) account
+
+## Links
+
+- [Elva](https://getelva.ai)
+- [Issues](https://github.com/Theneo-Inc/theneo-elva-cli/issues)
+- [Contributing](CONTRIBUTING.md)

{elva_cli-0.0.2 → elva_cli-0.0.4}/pyproject.toml

@@ -23,6 +23,7 @@ classifiers = [
 
 dependencies = [
   "typer>=0.15,<1.0",
+  "platformdirs>=4.2",
 ]
 
 [project.optional-dependencies]
@@ -91,7 +92,7 @@ ban-relative-imports = "all"
 [tool.mypy]
 python_version = "3.11"
 strict = true
-files = ["src"]
+files = ["src", "tests"]
 warn_unreachable = true
 enable_error_code = ["ignore-without-code", "redundant-expr"]
 

{elva_cli-0.0.2 → elva_cli-0.0.4}/src/elva_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.0.2'
-__version_tuple__ = version_tuple = (0, 0, 2)
+__version__ = version = '0.0.4'
+__version_tuple__ = version_tuple = (0, 0, 4)
 
 __commit_id__ = commit_id = None

elva_cli-0.0.4/src/elva_cli/errors.py

@@ -0,0 +1,90 @@
+"""Error taxonomy and the exit-code contract.
+
+Exit codes are a public API that pipelines branch on. Never renumber a shipped
+value, and never collapse VALIDATION into UNEXPECTED, callers rely on the
+difference between "your spec is wrong" and "the tool broke".
+
+Every ElvaError carries a stable machine code, a human message, and where one
+exists, the next action to take. Anything that escapes as a bare Exception is a
+"""
+
+from __future__ import annotations
+
+import enum
+
+
+class ExitCode(enum.IntEnum):
+    """Process exit statuses. Documented in docs/exit-codes.md."""
+
+    OK = 0
+    UNEXPECTED = 1
+    USAGE = 2
+    AUTH = 3
+    VALIDATION = 4
+    API = 5
+    INTERRUPTED = 130
+
+
+class ElvaError(Exception):
+    """Base class for every failure the user is meant to see."""
+
+    code: str = "ELVA_ERROR"
+    exit_code: ExitCode = ExitCode.UNEXPECTED
+    default_hint: str | None = None
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        hint: str | None = None,
+        code: str | None = None,
+        exit_code: ExitCode | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.hint = self.default_hint if hint is None else hint
+        if code is not None:
+            self.code = code
+        if exit_code is not None:
+            self.exit_code = exit_code
+
+    def __str__(self) -> str:
+        return self.message
+
+
+class UsageError(ElvaError):
+    """The command was invoked wrongly, or needs an answer it cannot ask for."""
+
+    code = "ELVA_USAGE"
+    exit_code = ExitCode.USAGE
+    default_hint = "Run 'elva --help' to see the available commands and options."
+
+
+class ConfigError(ElvaError):
+    """Configuration is missing or malformed."""
+
+    code = "ELVA_CONFIG"
+    exit_code = ExitCode.USAGE
+
+
+class AuthError(ElvaError):
+    """Not authenticated, or the stored credentials no longer work."""
+
+    code = "ELVA_AUTH"
+    exit_code = ExitCode.AUTH
+    default_hint = "Run 'elva auth login' to sign in."
+
+
+class ValidationError(ElvaError):
+    """The input spec is invalid. The CLI itself worked correctly."""
+
+    code = "ELVA_VALIDATION"
+    exit_code = ExitCode.VALIDATION
+
+
+class ApiError(ElvaError):
+    """The Elva API could not be reached, or returned a server error."""
+
+    code = "ELVA_API"
+    exit_code = ExitCode.API
+    default_hint = "Check your connection and try again."

elva_cli-0.0.4/src/elva_cli/main.py

@@ -0,0 +1,139 @@
+"""Typer root and the single error boundary."""
+
+from __future__ import annotations
+
+import os
+import platform
+import sys
+from typing import TYPE_CHECKING, Protocol, TypeGuard
+
+import typer
+
+from elva_cli.errors import ElvaError, ExitCode
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+app = typer.Typer(
+    name="elva",
+    help="Elva - CLI for Theneo Elva.",
+    no_args_is_help=True,
+    pretty_exceptions_enable=False,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+
+
+def _version_callback(value: bool) -> None:
+    if not value:
+        return
+    from elva_cli import __version__
+
+    machine = f"{platform.system().lower()}-{platform.machine()}"
+    typer.echo(f"elva {__version__} (python {platform.python_version()}, {machine})")
+    raise typer.Exit(ExitCode.OK)
+
+
+@app.callback()
+def root(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        callback=_version_callback,
+        is_eager=True,
+        help="Show the current build version.",
+    ),
+) -> None:
+    pass
+
+
+def report(error: ElvaError) -> None:
+    """Render a user-facing error to stderr as code, message, then next action."""
+    typer.secho(f"{error.code}: {error.message}", err=True, fg=typer.colors.RED)
+    if error.hint:
+        typer.secho(f"  -> {error.hint}", err=True, dim=True)
+
+
+def write_crash(exc: BaseException) -> Path | None:
+    """Persist a traceback for an unexpected failure and return its path.
+
+    Deliberately records no argv: a crash report is written to disk and kept, and
+    a mistyped secret on a command line must not outlive the process.
+    """
+    import time
+    import traceback
+
+    from elva_cli import __version__
+    from elva_cli.settings.paths import crash_dir
+
+    try:
+        directory = crash_dir()
+        directory.mkdir(parents=True, exist_ok=True)
+        target = directory / f"crash-{int(time.time())}-{os.getpid()}.log"
+        target.write_text(
+            f"elva {__version__}\n"
+            f"python {platform.python_version()} on {platform.platform()}\n\n"
+            + "".join(traceback.format_exception(exc)),
+            encoding="utf-8",
+        )
+    except OSError:
+        return None
+    return target
+
+
+class _FrameworkError(Protocol):
+    """The shape every vendored Click exception exposes."""
+
+    exit_code: int
+
+    def show(self) -> None: ...
+
+
+def _is_framework_error(exc: BaseException) -> TypeGuard[_FrameworkError]:
+    """Recognise a Typer/Click argument-parsing failure."""
+    return (
+        type(exc).__module__.startswith("typer")
+        and callable(getattr(exc, "show", None))
+        and isinstance(getattr(exc, "exit_code", None), int)
+    )
+
+
+def _run() -> int:
+    try:
+        app(standalone_mode=False)
+    except typer.Exit as exc:
+        return int(exc.exit_code)
+    except typer.Abort:
+        return int(ExitCode.INTERRUPTED)
+    except ElvaError as exc:
+        report(exc)
+        return int(exc.exit_code)
+    except KeyboardInterrupt:
+        typer.secho("interrupted", err=True, dim=True)
+        return int(ExitCode.INTERRUPTED)
+    except Exception as exc:
+        if _is_framework_error(exc):
+            exc.show()
+            return int(exc.exit_code)
+        path = write_crash(exc)
+        report(
+            ElvaError(
+                f"unexpected error: {type(exc).__name__}: {exc}",
+                code="ELVA_CRASH",
+                hint=(
+                    f"Details written to {path}. Please include that file when reporting this."
+                    if path
+                    else "Please report this, including the command you ran."
+                ),
+            )
+        )
+        return int(ExitCode.UNEXPECTED)
+    return int(ExitCode.OK)
+
+
+def main() -> None:
+    sys.exit(_run())
+
+
+if __name__ == "__main__":
+    main()

elva_cli-0.0.4/src/elva_cli/settings/paths.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import platformdirs
+
+APP_NAME = "elva"
+
+
+def cache_dir() -> Path:
+    """Per-user cache location: XDG on Linux, ~/Library on macOS, %LOCALAPPDATA% on Windows."""
+    return Path(platformdirs.user_cache_dir(APP_NAME, appauthor=False))
+
+
+def crash_dir() -> Path:
+    return cache_dir() / "crashes"

elva_cli-0.0.4/tests/cli/test_cli_exit_codes.py

@@ -0,0 +1,48 @@
+"""End-to-end exit codes, run as a real subprocess.
+
+Uses `python -m elva_cli` rather than the `elva` script so the tests do not
+depend on the console script being on PATH.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+
+
+def run(*args: str) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        [sys.executable, "-m", "elva_cli", *args],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+
+def test_version_exits_ok() -> None:
+    result = run("--version")
+    assert result.returncode == 0
+    assert result.stdout.startswith("elva ")
+
+
+def test_help_exits_ok() -> None:
+    assert run("--help").returncode == 0
+
+
+def test_no_args_is_help_and_exits_usage() -> None:
+    assert run().returncode == 2
+
+
+def test_unknown_option_exits_usage() -> None:
+    result = run("--definitely-not-an-option")
+    assert result.returncode == 2
+
+
+def test_unknown_command_exits_usage() -> None:
+    assert run("definitely-not-a-command").returncode == 2
+
+
+def test_no_traceback_ever_reaches_the_user() -> None:
+    for args in ([], ["--definitely-not-an-option"], ["definitely-not-a-command"]):
+        result = run(*args)
+        assert "Traceback (most recent call last)" not in result.stderr

elva_cli-0.0.4/tests/unit/test_error_boundary.py

@@ -0,0 +1,126 @@
+"""The single error boundary in main._run().
+
+Every failure mode is exercised here rather than through subprocesses, so the
+mapping from exception to exit code is asserted directly.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Never
+
+import pytest
+import typer
+
+from elva_cli import main
+from elva_cli.errors import ApiError, AuthError, ElvaError, ExitCode, ValidationError
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from pathlib import Path
+
+
+def _app_raising(exc: BaseException) -> Callable[..., Never]:
+    def fake_app(*_args: object, **_kwargs: object) -> Never:
+        raise exc
+
+    return fake_app
+
+
+def test_success_returns_ok(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(main, "app", lambda **_kwargs: None)
+    assert main._run() == ExitCode.OK
+
+
+def test_typer_exit_code_is_passed_through(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(main, "app", _app_raising(typer.Exit(0)))
+    assert main._run() == ExitCode.OK
+
+
+def test_abort_maps_to_interrupted(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(main, "app", _app_raising(typer.Abort()))
+    assert main._run() == ExitCode.INTERRUPTED
+
+
+def test_keyboard_interrupt_maps_to_130(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(main, "app", _app_raising(KeyboardInterrupt()))
+    assert main._run() == ExitCode.INTERRUPTED
+
+
+def test_framework_usage_error_maps_to_usage(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Typer vendors Click, so its parsing errors are recognised by protocol."""
+    monkeypatch.setattr(main, "app", _app_raising(typer.BadParameter("no such option")))
+    assert main._run() == ExitCode.USAGE
+
+
+@pytest.mark.parametrize(
+    ("error", "expected"),
+    [
+        (AuthError("expired"), ExitCode.AUTH),
+        (ValidationError("bad spec"), ExitCode.VALIDATION),
+        (ApiError("502"), ExitCode.API),
+        (ElvaError("generic"), ExitCode.UNEXPECTED),
+    ],
+)
+def test_elva_errors_use_their_own_exit_code(
+    monkeypatch: pytest.MonkeyPatch, error: ElvaError, expected: ExitCode
+) -> None:
+    monkeypatch.setattr(main, "app", _app_raising(error))
+    assert main._run() == expected
+
+
+def test_elva_error_prints_code_message_and_hint(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setattr(main, "app", _app_raising(AuthError("session expired")))
+    main._run()
+    err = capsys.readouterr().err
+    assert "ELVA_AUTH" in err
+    assert "session expired" in err
+    assert "elva auth login" in err
+
+
+def test_unexpected_exception_writes_a_crash_file_and_no_traceback(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str], tmp_path: Path
+) -> None:
+    monkeypatch.setattr("elva_cli.settings.paths.cache_dir", lambda: tmp_path, raising=True)
+    monkeypatch.setattr(main, "app", _app_raising(RuntimeError("kaboom")))
+
+    assert main._run() == ExitCode.UNEXPECTED
+
+    err = capsys.readouterr().err
+    assert "kaboom" in err
+    assert "Traceback (most recent call last)" not in err
+
+    crashes = list((tmp_path / "crashes").glob("crash-*.log"))
+    assert len(crashes) == 1
+    assert str(crashes[0]) in err
+
+    contents = crashes[0].read_text(encoding="utf-8")
+    assert "Traceback (most recent call last)" in contents
+    assert "RuntimeError: kaboom" in contents
+
+
+def test_crash_file_records_no_argv(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    """A crash report outlives the process; a secret on the command line must not."""
+    monkeypatch.setattr("elva_cli.settings.paths.cache_dir", lambda: tmp_path, raising=True)
+    monkeypatch.setattr("sys.argv", ["elva", "mcp", "create", "--secret", "hunter2"])
+    monkeypatch.setattr(main, "app", _app_raising(RuntimeError("kaboom")))
+
+    main._run()
+
+    crash = next(iter((tmp_path / "crashes").glob("crash-*.log")))
+    contents = crash.read_text(encoding="utf-8")
+    assert "hunter2" not in contents
+
+
+def test_unwritable_crash_dir_still_reports_the_error(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    def boom() -> Path:
+        raise OSError("read-only filesystem")
+
+    monkeypatch.setattr("elva_cli.settings.paths.cache_dir", boom, raising=True)
+    monkeypatch.setattr(main, "app", _app_raising(RuntimeError("kaboom")))
+
+    assert main._run() == ExitCode.UNEXPECTED
+    assert "kaboom" in capsys.readouterr().err

elva_cli-0.0.4/tests/unit/test_errors.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import pytest
+
+from elva_cli.errors import (
+    ApiError,
+    AuthError,
+    ConfigError,
+    ElvaError,
+    ExitCode,
+    UsageError,
+    ValidationError,
+)
+
+EVERY_ERROR = [ElvaError, UsageError, ConfigError, AuthError, ValidationError, ApiError]
+
+
+@pytest.mark.parametrize("cls", EVERY_ERROR)
+def test_every_error_carries_a_code_and_message(cls: type[ElvaError]) -> None:
+    error = cls("something went wrong")
+    assert error.message == "something went wrong"
+    assert str(error) == "something went wrong"
+    assert error.code.startswith("ELVA_")
+    assert isinstance(error.exit_code, ExitCode)
+
+
+@pytest.mark.parametrize("cls", EVERY_ERROR)
+def test_every_error_is_catchable_as_elva_error(cls: type[ElvaError]) -> None:
+    with pytest.raises(ElvaError):
+        raise cls("boom")
+
+
+def test_subclass_codes_and_exit_codes() -> None:
+    assert (UsageError("x").code, UsageError("x").exit_code) == ("ELVA_USAGE", ExitCode.USAGE)
+    assert (ConfigError("x").code, ConfigError("x").exit_code) == ("ELVA_CONFIG", ExitCode.USAGE)
+    assert (AuthError("x").code, AuthError("x").exit_code) == ("ELVA_AUTH", ExitCode.AUTH)
+    assert (ValidationError("x").code, ValidationError("x").exit_code) == (
+        "ELVA_VALIDATION",
+        ExitCode.VALIDATION,
+    )
+    assert (ApiError("x").code, ApiError("x").exit_code) == ("ELVA_API", ExitCode.API)
+
+
+def test_default_hint_supplies_a_next_action() -> None:
+    assert AuthError("session expired").hint == "Run 'elva auth login' to sign in."
+    assert UsageError("bad flag").hint is not None
+    assert ApiError("timed out").hint is not None
+
+
+def test_explicit_hint_overrides_the_default() -> None:
+    assert AuthError("nope", hint="Set ELVA_TOKEN.").hint == "Set ELVA_TOKEN."
+
+
+def test_hint_can_be_specific_where_no_default_makes_sense() -> None:
+    assert ValidationError("bad spec").hint is None
+    assert ValidationError("bad spec", hint="Fix line 12.").hint == "Fix line 12."
+
+
+def test_code_and_exit_code_can_be_overridden_per_instance() -> None:
+    error = ElvaError("odd", code="ELVA_WEIRD", exit_code=ExitCode.API)
+    assert error.code == "ELVA_WEIRD"
+    assert error.exit_code == ExitCode.API
+
+
+def test_overriding_an_instance_does_not_mutate_the_class() -> None:
+    ElvaError("odd", code="ELVA_WEIRD", exit_code=ExitCode.API)
+    assert ElvaError("plain").code == "ELVA_ERROR"
+    assert ElvaError("plain").exit_code == ExitCode.UNEXPECTED

elva_cli-0.0.4/tests/unit/test_exit_codes.py

@@ -0,0 +1,34 @@
+"""The exit-code contract.
+
+These assertions exist to fail loudly if anyone renumbers a shipped code. Exit
+codes are a public API: CI pipelines and agents branch on them, so changing one
+breaks callers we cannot see.
+"""
+
+from __future__ import annotations
+
+from elva_cli.errors import ExitCode
+
+
+def test_exact_values_are_frozen() -> None:
+    assert ExitCode.OK.value == 0
+    assert ExitCode.UNEXPECTED.value == 1
+    assert ExitCode.USAGE.value == 2
+    assert ExitCode.AUTH.value == 3
+    assert ExitCode.VALIDATION.value == 4
+    assert ExitCode.API.value == 5
+    assert ExitCode.INTERRUPTED.value == 130
+
+
+def test_validation_is_distinct_from_unexpected() -> None:
+    """The whole point of code 4: "your spec is wrong" != "the tool broke"."""
+    assert len({ExitCode.VALIDATION.value, ExitCode.UNEXPECTED.value}) == 2
+
+
+def test_values_are_unique() -> None:
+    values = [code.value for code in ExitCode]
+    assert len(values) == len(set(values))
+
+
+def test_codes_are_valid_posix_statuses() -> None:
+    assert all(0 <= code.value <= 255 for code in ExitCode)

elva_cli-0.0.2/PKG-INFO

@@ -1,131 +0,0 @@
-Metadata-Version: 2.5
-Name: elva-cli
-Version: 0.0.2
-Summary: Elva - CLI for Theneo Elva
-Project-URL: Homepage, https://getelva.ai
-Project-URL: Source, https://github.com/Theneo-Inc/theneo-elva-cli
-Project-URL: Issues, https://github.com/Theneo-Inc/theneo-elva-cli/issues
-Author-email: Theneo <support@theneo.io>
-Keywords: api,cli,documentation,elva,openapi,theneo
-Classifier: Development Status :: 3 - Alpha
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Software Development :: Documentation
-Classifier: Typing :: Typed
-Requires-Python: >=3.11
-Requires-Dist: typer<1.0,>=0.15
-Provides-Extra: dev
-Requires-Dist: mypy>=1.11; extra == 'dev'
-Requires-Dist: pytest>=8.2; extra == 'dev'
-Requires-Dist: ruff>=0.6; extra == 'dev'
-Description-Content-Type: text/markdown
-
-# Elva CLI
-
-CLI for Theneo Editor
-
-## Install
-
-Requires Python 3.11 or newer. Pick one:
-
-```bash
-uv tool install elva-cli      # recommended
-pipx install elva-cli         # equivalent, if you already use pipx
-```
-
-`elva` is then available from any directory, no virtualenv to activate:
-
-```bash
-elva --version
-elva --help
-```
-
-To try it without installing anything:
-
-```bash
-uvx --from elva-cli elva --version
-```
-
-### Why not `pip install`?
-
-`pip install elva-cli` into a system Python is blocked on Ubuntu, Debian, Fedora and
-Homebrew macOS by [PEP 668](https://peps.python.org/pep-0668/), which reports
-`externally-managed-environment`. `uv tool` and `pipx` sidestep it by installing into
-an isolated environment for you and putting `elva` on your `PATH` -- which is what you
-want for a command-line tool anyway. Inside an already-activated virtualenv, plain
-`pip install elva-cli` works fine.
-
-### Upgrade
-
-```bash
-uv tool upgrade elva-cli      # or: pipx upgrade elva-cli
-```
-
-
-## Development
-
-Requires Python 3.11 or newer.
-
-```bash
-git clone https://github.com/Theneo-Inc/theneo-elva-cli.git
-cd theneo-elva-cli
-
-python3 -m venv .venv
-source .venv/bin/activate          # Windows: .venv\Scripts\activate
-pip install -e ".[dev]"
-```
-
-`-e` installs in editable mode, so your source edits take effect immediately with
-no reinstall.
-
-Run it:
-
-```bash
-elva --version
-elva --help
-```
-
-```
-$ elva --version
-elva 0.0.1 (python 3.12.3, linux-x86_64)
-```
-
-`python -m elva_cli --version` runs the same entry point, if you prefer that form.
-
-
-### With uv (faster)
-
-If you have [uv](https://docs.astral.sh/uv/), it replaces the venv and pip steps:
-
-```bash
-uv sync --extra dev
-uv run elva --version
-```
-
-#### Running `elva` from any directory (development)
-
-To activate everywhere locally:
-
-```bash
-uv tool install --editable ~/Desktop/theneo-elva-cli
-```
-
-### Checks
-
-```bash
-ruff check .        # lint
-ruff format .       # format
-mypy                # types, strict
-```
-
-### Version numbers
-
-The version comes from the git tag via `hatch-vcs` -- there is nothing to bump by hand.
-An untagged checkout reports something like `0.0.post1.dev2+gc657326`, which PyPI will
-not accept; a tagged one reports a clean `0.0.1`.
-
-To cut a release, see [RELEASING.md](RELEASING.md).
-

elva_cli-0.0.2/README.md

@@ -1,106 +0,0 @@
-# Elva CLI
-
-CLI for Theneo Editor
-
-## Install
-
-Requires Python 3.11 or newer. Pick one:
-
-```bash
-uv tool install elva-cli      # recommended
-pipx install elva-cli         # equivalent, if you already use pipx
-```
-
-`elva` is then available from any directory, no virtualenv to activate:
-
-```bash
-elva --version
-elva --help
-```
-
-To try it without installing anything:
-
-```bash
-uvx --from elva-cli elva --version
-```
-
-### Why not `pip install`?
-
-`pip install elva-cli` into a system Python is blocked on Ubuntu, Debian, Fedora and
-Homebrew macOS by [PEP 668](https://peps.python.org/pep-0668/), which reports
-`externally-managed-environment`. `uv tool` and `pipx` sidestep it by installing into
-an isolated environment for you and putting `elva` on your `PATH` -- which is what you
-want for a command-line tool anyway. Inside an already-activated virtualenv, plain
-`pip install elva-cli` works fine.
-
-### Upgrade
-
-```bash
-uv tool upgrade elva-cli      # or: pipx upgrade elva-cli
-```
-
-
-## Development
-
-Requires Python 3.11 or newer.
-
-```bash
-git clone https://github.com/Theneo-Inc/theneo-elva-cli.git
-cd theneo-elva-cli
-
-python3 -m venv .venv
-source .venv/bin/activate          # Windows: .venv\Scripts\activate
-pip install -e ".[dev]"
-```
-
-`-e` installs in editable mode, so your source edits take effect immediately with
-no reinstall.
-
-Run it:
-
-```bash
-elva --version
-elva --help
-```
-
-```
-$ elva --version
-elva 0.0.1 (python 3.12.3, linux-x86_64)
-```
-
-`python -m elva_cli --version` runs the same entry point, if you prefer that form.
-
-
-### With uv (faster)
-
-If you have [uv](https://docs.astral.sh/uv/), it replaces the venv and pip steps:
-
-```bash
-uv sync --extra dev
-uv run elva --version
-```
-
-#### Running `elva` from any directory (development)
-
-To activate everywhere locally:
-
-```bash
-uv tool install --editable ~/Desktop/theneo-elva-cli
-```
-
-### Checks
-
-```bash
-ruff check .        # lint
-ruff format .       # format
-mypy                # types, strict
-```
-
-### Version numbers
-
-The version comes from the git tag via `hatch-vcs` -- there is nothing to bump by hand.
-An untagged checkout reports something like `0.0.post1.dev2+gc657326`, which PyPI will
-not accept; a tagged one reports a clean `0.0.1`.
-
-To cut a release, see [RELEASING.md](RELEASING.md).
-

elva_cli-0.0.2/src/elva_cli/errors.py

@@ -1,9 +0,0 @@
-"""Error taxonomy and the exit-code contract.
-
-Exit codes are a public API that pipelines branch on: 0 ok, 1 unexpected, 2 usage,
-3 auth, 4 spec failed validation, 5 network/API, 130 interrupted. Never renumber a
-shipped code, and never collapse 4 into 1 -- callers rely on the difference
-between "your spec is wrong" and "the tool broke".
-
-Every ElvaError carries a stable machine code, a message, and where one exists,
-the next action to take."""

elva_cli-0.0.2/src/elva_cli/main.py

@@ -1,55 +0,0 @@
-"""Typer root and the single error boundary.
-
-Nothing here does work. It resolves global options into a Ctx, dispatches, and
-turns whatever comes back into an exit code. Every user-visible failure path in
-the CLI funnels through here.
-
-Currently wired: --version and --help. Global flags, the Ctx and the error
-boundary land next.
-"""
-
-from __future__ import annotations
-
-import platform
-
-import typer
-
-app = typer.Typer(
-    name="elva",
-    help="Elva - CLI for Theneo Elva.",
-    no_args_is_help=True,
-    pretty_exceptions_enable=False,
-    context_settings={"help_option_names": ["-h", "--help"]},
-)
-
-
-def _version_callback(value: bool) -> None:
-    if not value:
-        return
-    from elva_cli import __version__
-
-    machine = f"{platform.system().lower()}-{platform.machine()}"
-    typer.echo(f"elva {__version__} (python {platform.python_version()}, {machine})")
-    raise typer.Exit(0)
-
-
-@app.callback()
-def root(
-    version: bool = typer.Option(
-        False,
-        "--version",
-        "-V",
-        callback=_version_callback,
-        is_eager=True,
-        help="Show the current build version.",
-    ),
-) -> None:
-    pass
-
-
-def main() -> None:
-    app()
-
-
-if __name__ == "__main__":
-    main()