fastapi-cloud-cli 0.18.0__tar.gz → 0.19.0__tar.gz

{fastapi_cloud_cli-0.18.0 → fastapi_cloud_cli-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastapi-cloud-cli
-Version: 0.18.0
+Version: 0.19.0
 Summary: Deploy and manage FastAPI Cloud apps from the command line 🚀
 Author-Email: Patrick Arminio <patrick@fastapilabs.com>
 License: MIT

{fastapi_cloud_cli-0.18.0 → fastapi_cloud_cli-0.19.0}/pyproject.toml

@@ -41,7 +41,7 @@ dependencies = [
     "fastar >= 0.10.0",
     "detect-installer>=0.1.0",
 ]
-version = "0.18.0"
+version = "0.19.0"
 
 [project.license]
 text = "MIT"

fastapi_cloud_cli-0.19.0/scripts/prepare_release.py

@@ -0,0 +1,216 @@
+"""Prepare a release by updating the package version and release notes."""
+
+import re
+from datetime import date
+from enum import Enum
+from pathlib import Path
+from typing import Annotated
+
+import typer
+
+VERSION_PATTERN = re.compile(r'(?m)^__version__ = "(\d+\.\d+\.\d+)"$')
+VERSION_HEADING_PATTERN = re.compile(r"(?m)^## (\d+\.\d+\.\d+)(?: \([^)]+\))?$")
+RELEASE_NOTES_HEADER = "# Release Notes\n\n"
+LATEST_CHANGES_HEADER = "## Latest Changes"
+
+
+class BumpType(str, Enum):
+    major = "major"
+    minor = "minor"
+    patch = "patch"
+
+
+app = typer.Typer()
+
+
+def parse_version(version: str) -> tuple[int, int, int]:
+    match = re.fullmatch(r"\d+\.\d+\.\d+", version)
+    if not match:
+        raise ValueError(f"Invalid version: {version!r}. Expected format: X.Y.Z")
+    major, minor, patch = version.split(".")
+    return int(major), int(minor), int(patch)
+
+
+def get_current_version(content: str, version_file: Path) -> str:
+    matches = list(VERSION_PATTERN.finditer(content))
+    if len(matches) != 1:
+        raise RuntimeError(
+            f"Expected exactly one __version__ assignment in {version_file}, "
+            f"found {len(matches)}"
+        )
+    return matches[0].group(1)
+
+
+def bump_version(version: str, bump: BumpType) -> str:
+    major, minor, patch = parse_version(version)
+    if bump == BumpType.major:
+        return f"{major + 1}.0.0"
+    if bump == BumpType.minor:
+        return f"{major}.{minor + 1}.0"
+    return f"{major}.{minor}.{patch + 1}"
+
+
+def update_version_file(content: str, version: str, version_file: Path) -> str:
+    current_version = get_current_version(content, version_file)
+    if parse_version(version) <= parse_version(current_version):
+        raise RuntimeError(
+            f"New version {version} must be greater than current version {current_version}"
+        )
+    return VERSION_PATTERN.sub(f'__version__ = "{version}"', content, count=1)
+
+
+def update_release_notes(
+    content: str, version: str, release_date: date, release_notes_file: Path
+) -> str:
+    if not content.startswith(RELEASE_NOTES_HEADER):
+        raise RuntimeError(
+            f"{release_notes_file} must start with {RELEASE_NOTES_HEADER!r}"
+        )
+    if re.search(rf"^## {re.escape(version)}(?: \([^)]+\))?$", content, re.M):
+        raise RuntimeError(f"Release notes already contain a section for {version}")
+
+    latest_header = f"{RELEASE_NOTES_HEADER}{LATEST_CHANGES_HEADER}\n"
+    if not content.startswith(latest_header):
+        raise RuntimeError(f"{release_notes_file} must start with {latest_header!r}")
+
+    release_header = f"## {version} ({release_date.isoformat()})"
+    return content.replace(
+        latest_header,
+        f"{RELEASE_NOTES_HEADER}{LATEST_CHANGES_HEADER}\n\n{release_header}\n",
+        1,
+    )
+
+
+def get_release_notes_body(content: str, version: str, release_notes_file: Path) -> str:
+    version_heading = re.compile(rf"(?m)^## {re.escape(version)}(?: \([^)]+\))?$")
+    match = version_heading.search(content)
+    if not match:
+        raise RuntimeError(
+            f"Could not find release notes section for {version} in {release_notes_file}"
+        )
+
+    next_match = VERSION_HEADING_PATTERN.search(content, match.end())
+    end = next_match.start() if next_match else len(content)
+    body = content[match.end() : end].strip()
+    if not body:
+        raise RuntimeError(
+            f"Release notes section for {version} in {release_notes_file} is empty"
+        )
+    return f"{body}\n"
+
+
+@app.command()
+def prepare(
+    bump: Annotated[
+        BumpType,
+        typer.Argument(
+            envvar="PREPARE_RELEASE_BUMP",
+            help="The release bump to make: major, minor, or patch.",
+        ),
+    ],
+    version_file: Annotated[
+        Path,
+        typer.Option(
+            envvar="PREPARE_RELEASE_VERSION_FILE",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            writable=True,
+            help="Path to the Python file containing the __version__ assignment.",
+        ),
+    ],
+    release_notes_file: Annotated[
+        Path,
+        typer.Option(
+            envvar="PREPARE_RELEASE_RELEASE_NOTES_FILE",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            writable=True,
+            help="Path to the release notes Markdown file.",
+        ),
+    ],
+    release_date: Annotated[
+        str,
+        typer.Option(
+            "--date",
+            envvar="PREPARE_RELEASE_DATE",
+            help="Release date in YYYY-MM-DD format. Defaults to today.",
+        ),
+    ] = date.today().isoformat(),
+) -> None:
+    parsed_release_date = date.fromisoformat(release_date or date.today().isoformat())
+
+    version_file_content = version_file.read_text()
+    release_notes_content = release_notes_file.read_text()
+    version = bump_version(
+        get_current_version(version_file_content, version_file), bump
+    )
+
+    version_file.write_text(
+        update_version_file(version_file_content, version, version_file)
+    )
+    release_notes_file.write_text(
+        update_release_notes(
+            release_notes_content, version, parsed_release_date, release_notes_file
+        )
+    )
+
+    typer.echo(f"Prepared release {version} ({parsed_release_date.isoformat()})")
+
+
+@app.command()
+def current_version(
+    version_file: Annotated[
+        Path,
+        typer.Option(
+            envvar="PREPARE_RELEASE_VERSION_FILE",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            help="Path to the Python file containing the __version__ assignment.",
+        ),
+    ],
+) -> None:
+    typer.echo(get_current_version(version_file.read_text(), version_file))
+
+
+@app.command()
+def release_notes(
+    version_file: Annotated[
+        Path,
+        typer.Option(
+            envvar="PREPARE_RELEASE_VERSION_FILE",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            help="Path to the Python file containing the __version__ assignment.",
+        ),
+    ],
+    release_notes_file: Annotated[
+        Path,
+        typer.Option(
+            envvar="PREPARE_RELEASE_RELEASE_NOTES_FILE",
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            readable=True,
+            help="Path to the release notes Markdown file.",
+        ),
+    ],
+) -> None:
+    version = get_current_version(version_file.read_text(), version_file)
+    typer.echo(
+        get_release_notes_body(
+            release_notes_file.read_text(), version, release_notes_file
+        ),
+        nl=False,
+    )
+
+
+if __name__ == "__main__":
+    app()

fastapi_cloud_cli-0.19.0/src/fastapi_cloud_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.19.0"

{fastapi_cloud_cli-0.18.0 → fastapi_cloud_cli-0.19.0}/src/fastapi_cloud_cli/commands/deploy.py

@@ -396,9 +396,7 @@ def _configure_app(
     initial_directory = selected_app.directory if selected_app else ""
 
     directory_input = toolkit.input(
-        title=(
-            "Directory where your app's pyproject.toml file lives (e.g. src, backend):"
-        ),
+        title=("Directory where your app's pyproject.toml file lives (e.g. backend):"),
         tag="dir",
         value=initial_directory or "",
         placeholder=(

{fastapi_cloud_cli-0.18.0 → fastapi_cloud_cli-0.19.0}/src/fastapi_cloud_cli/commands/env.py

@@ -4,19 +4,27 @@ from typing import Annotated, Any
 
 import typer
 from pydantic import BaseModel
+from rich import box
+from rich.table import Table
+from rich.text import Text
 
 from fastapi_cloud_cli.utils.api import APIClient
 from fastapi_cloud_cli.utils.apps import get_app_config
 from fastapi_cloud_cli.utils.auth import Identity
 from fastapi_cloud_cli.utils.cli import get_rich_toolkit
+from fastapi_cloud_cli.utils.dates import format_last_updated
 from fastapi_cloud_cli.utils.env import validate_environment_variable_name
 
 logger = logging.getLogger(__name__)
 
+ENV_VAR_VALUE_MAX_LENGTH = 40
+
 
 class EnvironmentVariable(BaseModel):
     name: str
     value: str | None = None
+    is_secret: bool = False
+    updated_at: str | None = None
 
 
 class EnvironmentVariableResponse(BaseModel):
@@ -53,11 +61,47 @@ def _set_environment_variable(
     response.raise_for_status()
 
 
+def _format_env_var_value(env_var: EnvironmentVariable) -> Text:
+    if env_var.value is None:
+        placeholder = "[secret]" if env_var.is_secret else "-"
+
+        return Text(placeholder, style="dim")
+
+    value = env_var.value.replace("\r", "\\r").replace("\n", "\\n")
+
+    if len(value) > ENV_VAR_VALUE_MAX_LENGTH:
+        value = f"{value[: ENV_VAR_VALUE_MAX_LENGTH - 3]}..."
+
+    return Text(value)
+
+
+def _get_environment_variables_table(
+    environment_variables: list[EnvironmentVariable],
+) -> Table:
+    table = Table(
+        box=box.SIMPLE_HEAD,
+        pad_edge=False,
+        show_edge=False,
+    )
+    table.add_column("Key", no_wrap=True)
+    table.add_column("Value", overflow="ellipsis", max_width=ENV_VAR_VALUE_MAX_LENGTH)
+    table.add_column("Last updated", style="dim", no_wrap=True)
+
+    for env_var in environment_variables:
+        table.add_row(
+            Text(env_var.name),
+            _format_env_var_value(env_var),
+            Text(format_last_updated(env_var.updated_at)),
+        )
+
+    return table
+
+
 env_app = typer.Typer()
 
 
-@env_app.command()
-def list(
+@env_app.command("list")
+def list_variables(
     path: Annotated[
         Path | None,
         typer.Argument(
@@ -106,11 +150,7 @@ def list(
             toolkit.print("No environment variables found.")
             return
 
-        toolkit.print("Environment variables:")
-        toolkit.print_line()
-
-        for env_var in environment_variables.data:
-            toolkit.print(f"[bold]{env_var.name}[/]")
+        toolkit.print(_get_environment_variables_table(environment_variables.data))
 
 
 @env_app.command()

{fastapi_cloud_cli-0.18.0 → fastapi_cloud_cli-0.19.0}/src/fastapi_cloud_cli/commands/login.py

@@ -34,6 +34,7 @@ def _start_device_authorization(
     response = client.post(
         "/login/device/authorization", data={"client_id": settings.client_id}
     )
+    logger.debug(f"Device authorization response status code: {response.status_code}")
 
     response.raise_for_status()
 
@@ -43,6 +44,7 @@ def _start_device_authorization(
 def _fetch_access_token(client: httpx.Client, device_code: str, interval: int) -> str:
     settings = Settings.get()
 
+    logger.debug("Starting to poll for access token")
     while True:
         response = client.post(
             "/login/device/token",
@@ -52,22 +54,27 @@ def _fetch_access_token(client: httpx.Client, device_code: str, interval: int) -
                 "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
             },
         )
+        logger.debug(f"Token response status code: {response.status_code}")
 
         if response.status_code not in (200, 400):
             response.raise_for_status()
 
         if response.status_code == 400:
             data = response.json()
+            error = data.get("error")
+            logger.debug(f"Token response error: {error}")
 
-            if data.get("error") != "authorization_pending":
+            if error != "authorization_pending":
                 response.raise_for_status()
 
         if response.status_code == 200:
             break
 
+        logger.debug(f"Sleeping for {interval} seconds before retrying...")
         time.sleep(interval)
 
     response_data = TokenResponse.model_validate_json(response.text)
+    logger.debug("Access token received successfully.")
 
     return response_data.access_token
 
@@ -112,7 +119,8 @@ def login() -> Any:
             toolkit.print_line()
 
             with toolkit.progress("Waiting for user to authorize...") as progress:
-                typer.launch(url)
+                launch_cmd_res = typer.launch(url)
+                logger.debug(f"Launch command result: {launch_cmd_res}")
 
                 with client.handle_http_errors(progress):
                     access_token = _fetch_access_token(

fastapi_cloud_cli-0.19.0/src/fastapi_cloud_cli/utils/dates.py

@@ -0,0 +1,45 @@
+from datetime import datetime, timezone
+
+
+def format_last_updated(updated_at: str | None) -> str:
+    if updated_at is None:
+        return "-"
+
+    try:
+        updated = datetime.fromisoformat(updated_at.replace("Z", "+00:00"))
+    except ValueError:
+        return updated_at
+
+    if updated.tzinfo is None:
+        updated = updated.replace(tzinfo=timezone.utc)
+
+    now = datetime.now(timezone.utc)
+    seconds = int((now - updated).total_seconds())
+
+    if seconds < 60:
+        return "just now"
+
+    minutes = seconds // 60
+    if minutes < 60:
+        return _format_time_ago(minutes, "minute")
+
+    hours = minutes // 60
+    if hours < 24:
+        return _format_time_ago(hours, "hour")
+
+    days = hours // 24
+    if days < 30:
+        return _format_time_ago(days, "day")
+
+    months = days // 30
+    if months < 12:
+        return _format_time_ago(months, "month")
+
+    years = days // 365
+    return _format_time_ago(years, "year")
+
+
+def _format_time_ago(value: int, unit: str) -> str:
+    suffix = "" if value == 1 else "s"
+
+    return f"{value} {unit}{suffix} ago"

{fastapi_cloud_cli-0.18.0 → fastapi_cloud_cli-0.19.0}/tests/test_cli.py

@@ -81,4 +81,4 @@ def test_embedded_fastapi_cli_prints_forced_update_message(
     assert result.exit_code == 0, result.output
     assert "No credentials found" in result.output
     assert "A newer FastAPI Cloud CLI version is available" in result.output
-    assert "0.17.1 → 999.0.0" in result.output
+    assert "→ 999.0.0" in result.output

fastapi_cloud_cli-0.19.0/tests/test_dates.py

@@ -0,0 +1,27 @@
+from datetime import datetime, timezone
+
+import pytest
+import time_machine
+
+from fastapi_cloud_cli.utils.dates import format_last_updated
+
+
+@time_machine.travel(datetime(2026, 5, 22, 12, 0, tzinfo=timezone.utc), tick=False)
+@pytest.mark.parametrize(
+    ("updated_at", "expected"),
+    [
+        ("2026-05-22T11:59:30Z", "just now"),
+        ("2026-05-22T11:59:00Z", "1 minute ago"),
+        ("2026-05-22T11:30:00", "30 minutes ago"),
+        ("2026-05-22T10:00:00Z", "2 hours ago"),
+        ("2025-05-22T12:00:00Z", "1 year ago"),
+    ],
+)
+def test_format_last_updated_formats_relative_time(
+    updated_at: str, expected: str
+) -> None:
+    assert format_last_updated(updated_at) == expected
+
+
+def test_format_last_updated_returns_invalid_dates_unchanged() -> None:
+    assert format_last_updated("not-a-date") == "not-a-date"

{fastapi_cloud_cli-0.18.0 → fastapi_cloud_cli-0.19.0}/tests/test_env_list.py

@@ -1,7 +1,9 @@
+from datetime import datetime, timezone
 from pathlib import Path
 
 import pytest
 import respx
+import time_machine
 from httpx import Response
 from typer.testing import CliRunner
 
@@ -14,6 +16,10 @@ runner = CliRunner()
 assets_path = Path(__file__).parent / "assets"
 
 
+def _normalize_output(output: str) -> str:
+    return "\n".join(line.rstrip() for line in output.strip("\n").splitlines())
+
+
 def test_shows_a_message_if_not_logged_in(logged_out_cli: None) -> None:
     result = runner.invoke(app, ["env", "list"])
 
@@ -85,6 +91,83 @@ def test_shows_environment_variables_names(
     assert "API_KEY" in result.output
 
 
+@pytest.mark.respx
+@time_machine.travel(datetime(2026, 5, 22, 12, 0, tzinfo=timezone.utc), tick=False)
+def test_shows_environment_variables_in_compact_table(
+    logged_in_cli: None, respx_mock: respx.MockRouter, configured_app: ConfiguredApp
+) -> None:
+    respx_mock.get(f"/apps/{configured_app.app_id}/environment-variables/").mock(
+        return_value=Response(
+            200,
+            json={
+                "data": [
+                    {
+                        "name": "APP_URL",
+                        "value": "https://tryshot.app",
+                        "updated_at": "2026-05-10T12:00:00Z",
+                    },
+                    {
+                        "name": "SENTRY_ENVIRONMENT",
+                        "value": "production",
+                        "updated_at": "2026-03-22T12:00:00Z",
+                    },
+                ]
+            },
+        )
+    )
+
+    with changing_dir(configured_app.path):
+        result = runner.invoke(app, ["env", "list"])
+
+    assert result.exit_code == 0
+    assert _normalize_output(result.output) == (
+        "Key                  Value                 Last updated\n"
+        "───────────────────────────────────────────────────────\n"
+        "APP_URL              https://tryshot.app   12 days ago\n"
+        "SENTRY_ENVIRONMENT   production            2 months ago"
+    )
+
+
+@pytest.mark.respx
+@time_machine.travel(datetime(2026, 5, 22, 12, 0, tzinfo=timezone.utc), tick=False)
+def test_truncates_values_and_marks_secrets_in_compact_table(
+    logged_in_cli: None, respx_mock: respx.MockRouter, configured_app: ConfiguredApp
+) -> None:
+    long_value = "12345678901234567890123456789012345678901234567890"
+
+    respx_mock.get(f"/apps/{configured_app.app_id}/environment-variables/").mock(
+        return_value=Response(
+            200,
+            json={
+                "data": [
+                    {
+                        "name": "LONG_VALUE",
+                        "value": long_value,
+                        "updated_at": "2026-03-22T12:00:00Z",
+                    },
+                    {
+                        "name": "SECRET_KEY",
+                        "is_secret": True,
+                        "updated_at": "2026-04-22T12:00:00Z",
+                    },
+                ]
+            },
+        )
+    )
+
+    with changing_dir(configured_app.path):
+        result = runner.invoke(app, ["env", "list"])
+
+    assert result.exit_code == 0
+    assert _normalize_output(result.output) == (
+        "Key          Value                                      Last updated\n"
+        "────────────────────────────────────────────────────────────────────\n"
+        "LONG_VALUE   1234567890123456789012345678901234567...   2 months ago\n"
+        "SECRET_KEY   [secret]                                   1 month ago"
+    )
+    assert long_value not in result.output
+
+
 @pytest.mark.respx
 def test_shows_secret_environment_variables_without_value(
     logged_in_cli: None, respx_mock: respx.MockRouter, configured_app: ConfiguredApp

fastapi_cloud_cli-0.19.0/tests/test_prepare_release.py

@@ -0,0 +1,298 @@
+from datetime import date
+from pathlib import Path
+
+import pytest
+from typer.testing import CliRunner
+
+from scripts.prepare_release import (
+    BumpType,
+    app,
+    bump_version,
+    get_release_notes_body,
+    update_release_notes,
+    update_version_file,
+)
+
+runner = CliRunner()
+
+
+@pytest.mark.parametrize(
+    ("current_version", "bump", "new_version"),
+    [
+        ("0.18.0", BumpType.major, "1.0.0"),
+        ("0.18.0", BumpType.minor, "0.19.0"),
+        ("0.18.0", BumpType.patch, "0.18.1"),
+    ],
+)
+def test_bump_version(current_version: str, bump: BumpType, new_version: str) -> None:
+    assert bump_version(current_version, bump) == new_version
+
+
+def test_update_version_file() -> None:
+    content = '__version__ = "0.18.0"\n'
+
+    new_content = update_version_file(
+        content, "0.18.1", Path("src/fastapi_cloud_cli/__init__.py")
+    )
+
+    assert new_content == '__version__ = "0.18.1"\n'
+
+
+def test_update_version_file_requires_newer_version() -> None:
+    content = '__version__ = "0.18.0"\n'
+
+    with pytest.raises(RuntimeError, match="must be greater"):
+        update_version_file(
+            content, "0.18.0", Path("src/fastapi_cloud_cli/__init__.py")
+        )
+
+
+def test_update_release_notes() -> None:
+    content = """# Release Notes
+
+## Latest Changes
+
+### Fixes
+
+* Fix something.
+
+## 0.18.0 (2026-05-22)
+
+### Fixes
+
+* Previous fix.
+"""
+
+    new_content = update_release_notes(
+        content, "0.18.1", date(2026, 5, 30), Path("release-notes.md")
+    )
+
+    assert (
+        new_content
+        == """# Release Notes
+
+## Latest Changes
+
+## 0.18.1 (2026-05-30)
+
+### Fixes
+
+* Fix something.
+
+## 0.18.0 (2026-05-22)
+
+### Fixes
+
+* Previous fix.
+"""
+    )
+
+
+def test_update_release_notes_rejects_existing_version() -> None:
+    content = """# Release Notes
+
+## Latest Changes
+
+## 0.18.1 (2026-05-30)
+"""
+
+    with pytest.raises(RuntimeError, match="already contain"):
+        update_release_notes(
+            content, "0.18.1", date(2026, 5, 30), Path("release-notes.md")
+        )
+
+
+def test_get_release_notes_body_with_dated_heading() -> None:
+    content = """# Release Notes
+
+## Latest Changes
+
+## 0.18.1 (2026-05-30)
+
+### Fixes
+
+* Fix something.
+
+## 0.18.0 (2026-05-22)
+
+### Fixes
+
+* Previous fix.
+"""
+
+    body = get_release_notes_body(content, "0.18.1", Path("release-notes.md"))
+
+    assert (
+        body
+        == """### Fixes
+
+* Fix something.
+"""
+    )
+
+
+def test_get_release_notes_body_with_plain_heading() -> None:
+    content = """# Release Notes
+
+## Latest Changes
+
+## 0.18.1
+
+### Fixes
+
+* Fix something.
+"""
+
+    body = get_release_notes_body(content, "0.18.1", Path("release-notes.md"))
+
+    assert body == "### Fixes\n\n* Fix something.\n"
+
+
+def test_get_release_notes_body_allows_non_version_h2_content() -> None:
+    content = """# Release Notes
+
+## Latest Changes
+
+## 0.18.1
+
+## Highlights
+
+* Fix something.
+
+## 0.18.0
+
+* Previous fix.
+"""
+
+    body = get_release_notes_body(content, "0.18.1", Path("release-notes.md"))
+
+    assert body == "## Highlights\n\n* Fix something.\n"
+
+
+def test_get_release_notes_body_requires_version_section() -> None:
+    content = "# Release Notes\n\n## Latest Changes\n"
+
+    with pytest.raises(RuntimeError, match="Could not find"):
+        get_release_notes_body(content, "0.18.1", Path("release-notes.md"))
+
+
+def test_get_release_notes_body_requires_non_empty_section() -> None:
+    content = """# Release Notes
+
+## Latest Changes
+
+## 0.18.1
+
+## 0.18.0
+
+* Previous fix.
+"""
+
+    with pytest.raises(RuntimeError, match="is empty"):
+        get_release_notes_body(content, "0.18.1", Path("release-notes.md"))
+
+
+def test_cli_updates_configured_files(tmp_path: Path) -> None:
+    version_file = tmp_path / "src" / "fastapi_cloud_cli" / "__init__.py"
+    version_file.parent.mkdir(parents=True)
+    version_file.write_text('__version__ = "0.18.0"\n')
+    release_notes_file = tmp_path / "release-notes.md"
+    release_notes_file.write_text(
+        """# Release Notes
+
+## Latest Changes
+
+### Fixes
+
+* Fix something.
+"""
+    )
+
+    result = runner.invoke(
+        app,
+        [
+            "prepare",
+            "patch",
+            "--version-file",
+            str(version_file),
+            "--release-notes-file",
+            str(release_notes_file),
+            "--date",
+            "2026-05-30",
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert "Prepared release 0.18.1 (2026-05-30)" in result.output
+    assert version_file.read_text() == '__version__ = "0.18.1"\n'
+    assert "## 0.18.1 (2026-05-30)" in release_notes_file.read_text()
+
+
+def test_cli_accepts_env_vars(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    version_file = tmp_path / "src" / "fastapi_cloud_cli" / "__init__.py"
+    version_file.parent.mkdir(parents=True)
+    version_file.write_text('__version__ = "0.18.0"\n')
+    release_notes_file = tmp_path / "release-notes.md"
+    release_notes_file.write_text("# Release Notes\n\n## Latest Changes\n")
+    monkeypatch.setenv("PREPARE_RELEASE_BUMP", "minor")
+    monkeypatch.setenv("PREPARE_RELEASE_VERSION_FILE", str(version_file))
+    monkeypatch.setenv("PREPARE_RELEASE_RELEASE_NOTES_FILE", str(release_notes_file))
+    monkeypatch.setenv("PREPARE_RELEASE_DATE", "2026-05-30")
+
+    result = runner.invoke(app, ["prepare"])
+
+    assert result.exit_code == 0, result.output
+    assert "Prepared release 0.19.0 (2026-05-30)" in result.output
+    assert version_file.read_text() == '__version__ = "0.19.0"\n'
+    assert "## 0.19.0 (2026-05-30)" in release_notes_file.read_text()
+
+
+def test_cli_prints_current_version(tmp_path: Path) -> None:
+    version_file = tmp_path / "src" / "fastapi_cloud_cli" / "__init__.py"
+    version_file.parent.mkdir(parents=True)
+    version_file.write_text('__version__ = "0.18.0"\n')
+
+    result = runner.invoke(
+        app,
+        [
+            "current-version",
+            "--version-file",
+            str(version_file),
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert result.output == "0.18.0\n"
+
+
+def test_cli_prints_release_notes(tmp_path: Path) -> None:
+    version_file = tmp_path / "src" / "fastapi_cloud_cli" / "__init__.py"
+    version_file.parent.mkdir(parents=True)
+    version_file.write_text('__version__ = "0.18.1"\n')
+    release_notes_file = tmp_path / "release-notes.md"
+    release_notes_file.write_text(
+        """# Release Notes
+
+## Latest Changes
+
+## 0.18.1 (2026-05-30)
+
+### Fixes
+
+* Fix something.
+"""
+    )
+
+    result = runner.invoke(
+        app,
+        [
+            "release-notes",
+            "--version-file",
+            str(version_file),
+            "--release-notes-file",
+            str(release_notes_file),
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert result.output == "### Fixes\n\n* Fix something.\n"

{fastapi_cloud_cli-0.18.0 → fastapi_cloud_cli-0.19.0}/tests/test_version_check.py

@@ -279,7 +279,7 @@ def test_format_update_message(monkeypatch: pytest.MonkeyPatch) -> None:
     message = format_update_message(VersionUpdate(current="0.17.1", latest="0.18.0"))
 
     assert not message.startswith("\n")
-    assert "0.17.1 → [bold]0.18.0[/]" in message
+    assert "→ [bold]0.18.0[/]" in message
     assert '\n\nRun "[blue]uv tool upgrade fastapi-cloud-cli[/]" to upgrade.' in message
     assert "https://pypi.org/project/fastapi-cloud-cli/" not in message
 
@@ -340,7 +340,7 @@ def test_background_check_stores_result_and_returns_message(
 
     assert message is not None
     assert "A newer FastAPI Cloud CLI version is available" in message
-    assert "0.17.1 → [bold]0.18.0[/]" in message
+    assert "→ [bold]0.18.0[/]" in message
     assert check.get_update_message() is None
 
 

fastapi_cloud_cli-0.18.0/src/fastapi_cloud_cli/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.18.0"