quoll-cli 0.2.0__py3-none-any.whl

quoll/commands/_common.py

@@ -0,0 +1,145 @@
+"""Helpers shared by the commands (`quoll ci`, `quoll docker`, `quoll cd`...)."""
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Any, List, Optional
+
+import questionary
+import typer
+from rich.syntax import Syntax
+
+from quoll import languages, platforms
+from quoll.config.quoll_toml import CONFIG_FILE
+from quoll.config.settings import settings
+from quoll.config.store import load_stored_token, save_token
+from quoll.console import console
+from quoll.files import PlannedFile, write
+
+DirOption = typer.Option(Path("."), "--dir", "-d", help="Project directory.")
+
+# CLI of each platform that can hand over its token: `gh auth token`, `glab config get token`.
+_CLI_TOKEN = {
+    "github": lambda host: ["gh", "auth", "token"],
+    "gitlab": lambda host: ["glab", "config", "get", "token", "--host", host or "gitlab.com"],
+}
+
+
+def platform_option() -> Any:
+    return typer.Option(
+        None, "--platform", help=f"{' or '.join(platforms.NAMES)} (default: detected from the git remote)."
+    )
+
+
+def check_platform(name: Optional[str]) -> None:
+    if name is not None and name not in platforms.NAMES:
+        console.print(f"[red]Error:[/red] unknown platform '{name}' (expected one of: {', '.join(platforms.NAMES)}).")
+        raise typer.Exit(1)
+
+
+def ensure_token(platform: str, host: Optional[str] = None) -> bool:
+    """A token for `platform` in settings: from the environment, the platform's CLI (gh, glab: the session the user
+    keeps fresh), the one stored in ~/.config/quoll, or asked."""
+    attr = f"{platform}_token"
+    if getattr(settings, attr):
+        return True
+    token = _cli_token(platform, host) or load_stored_token(platform)
+    if not token:
+        label = platforms.get(platform).label
+        scope = "repo" if platform == "github" else "api"
+        token = ask(questionary.password(f"{label} token ({scope} scope)"))
+        if not token:
+            return False
+        save_token(token, platform)
+        console.print("[dim]Token saved to ~/.config/quoll/config.toml[/dim]")
+    setattr(settings, attr, token)
+    return True
+
+
+def _cli_token(platform: str, host: Optional[str]) -> str:
+    command = _CLI_TOKEN[platform](host)
+    if not shutil.which(command[0]):
+        return ""
+    try:
+        result = subprocess.run(command, capture_output=True, text=True, timeout=5)
+    except (OSError, subprocess.SubprocessError):
+        return ""
+    return result.stdout.strip() if result.returncode == 0 else ""
+
+
+def resolve_dir(project_dir: Path) -> Path:
+    project_dir = project_dir.resolve()
+    if not project_dir.is_dir():
+        console.print(f"[red]Error:[/red] '{project_dir}' is not a directory.")
+        raise typer.Exit(1)
+    return project_dir
+
+
+def ask(question: Any) -> Any:
+    answer = question.ask()
+    if answer is None:  # Ctrl-C
+        raise typer.Exit(130)
+    return answer
+
+
+def supported_hint() -> str:
+    lines = [f"  {lang.name}: {', '.join(lang.markers)}" for lang in languages.available()]
+    return "Supported languages (detected from these files):\n" + "\n".join(lines)
+
+
+def print_diff(f: PlannedFile) -> None:
+    diff = f.diff()
+    if diff:
+        console.print(Syntax(diff, "diff", theme="ansi_dark", background_color="default", word_wrap=True))
+
+
+def confirm_overwrite(files: List[PlannedFile], *, yes: bool, force: bool, already_shown: bool = False) -> bool:
+    """Refuse to replace hand-written files unless --force or the user agrees."""
+    for f in files:
+        if f.existing is None or not f.changed:
+            continue
+        if not f.managed and not force:
+            console.print(f"\n[yellow]![/yellow] {f.path} exists and was not generated by quoll.")
+            if yes:
+                console.print("  Re-run with [bold]--force[/bold] to replace it.")
+                return False
+            if not already_shown:
+                print_diff(f)
+            if not ask(questionary.confirm(f"Replace {f.path}?", default=False)):
+                return False
+    return True
+
+
+def update_files(project_dir: Path, files: List[PlannedFile], *, yes: bool, force: bool, what: str) -> None:
+    """Show the diff of the changed files, confirm, write them."""
+    changed = [f for f in files if f.changed]
+    if not changed:
+        console.print(f"[green]✓[/green] {what} up to date.")
+        return
+    for f in changed:
+        print_diff(f)
+    if not confirm_overwrite(changed, yes=yes, force=force, already_shown=True):
+        raise typer.Exit(1)
+    if not yes and not ask(questionary.confirm("Write these changes?", default=True)):
+        raise typer.Exit(1)
+    write(project_dir, changed)
+    for f in changed:
+        console.print(f"[green]✓[/green] {f.path} updated")
+
+
+def check_files(files: List[PlannedFile], command: str) -> None:
+    """Exit 1 when a file is missing or differs from quoll.toml."""
+    stale = False
+    for f in files:
+        if f.existing is None:
+            console.print(f"[red]✗[/red] {f.path} is missing. Run [bold]quoll {command} update[/bold].")
+            stale = True
+        elif f.changed:
+            print_diff(f)
+            console.print(f"[red]✗[/red] {f.path} is out of date. Run [bold]quoll {command} update[/bold].")
+            stale = True
+        else:
+            console.print(f"[green]✓[/green] {f.path} matches {CONFIG_FILE}.")
+    if stale:
+        raise typer.Exit(1)

quoll/commands/_workspace.py

@@ -0,0 +1,83 @@
+"""Regenerating a workspace's shared files once its members changed (`quoll add service`, `quoll remove service`)."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List, NamedTuple, Optional, Set
+
+from quoll import platforms
+from quoll.commands import cd as cd_command
+from quoll.commands import docker as docker_command
+from quoll.config.quoll_toml import ConfigError
+from quoll.console import console
+from quoll.files import MARKER, PlannedFile, write
+from quoll.platforms.github.ci import DEPENDABOT_PATH, render_dependabot
+from quoll.workspace import load_deliveries, load_repo
+
+
+class Snapshot(NamedTuple):
+    """What quoll generated for the members before they changed."""
+
+    paths: Set[Path]
+    dependabot: Optional[str]
+
+
+def generated(root: Path, platform: str) -> List[PlannedFile]:
+    """Every file quoll generates from the members: the pipeline, the root compose.yaml, the deliveries, the charts
+    (which know the other members' URLs)."""
+    from quoll.commands.k8s import chart_files  # it refreshes the workspace too
+
+    files = [*platforms.get(platform).ci_files(root, load_repo(root)), *docker_command._workspace_files(root)]
+    files += chart_files(root)
+    try:
+        files += cd_command._plan(root, load_deliveries(root))
+    except ConfigError:  # no member publishes an image
+        pass
+    return files
+
+
+def snapshot(root: Path, platform: str) -> Snapshot:
+    return Snapshot({f.path for f in generated(root, platform)}, _dependabot(root, platform))
+
+
+def refresh(root: Path, platform: str, before: Snapshot, by_hand: str, members_changed: bool = True) -> None:
+    """Write the files the change affects, delete the ones it made useless (a member's delivery...). Files written
+    by hand are left alone: `by_hand` says what to change in them. Dependabot's config only follows the members."""
+    files = generated(root, platform)
+    for f in files:
+        if f.changed and f.managed and not (f.create_only and f.existing is not None):
+            write(root, [f])
+            console.print(f"[green]✓[/green] {f.path}")
+        elif f.changed and not f.managed:
+            console.print(f"[yellow]![/yellow] {f.path} was written by hand: {by_hand}.")
+    for path in sorted(before.paths - {f.path for f in files}):
+        target = root / path
+        if target.exists() and MARKER in target.read_text():
+            target.unlink()
+            remove_empty_parents(root, target)
+            console.print(f"[green]✓[/green] {path} removed")
+
+    # Dependabot's config is the project's once created: updated only if nobody changed it since.
+    target = root / DEPENDABOT_PATH
+    if members_changed and before.dependabot is not None and target.exists():
+        current = _dependabot(root, platform)
+        if target.read_text() != before.dependabot:
+            console.print(f"[yellow]![/yellow] {DEPENDABOT_PATH} was edited: {by_hand}.")
+        elif current is not None and current != before.dependabot:
+            target.write_text(current)
+            console.print(f"[green]✓[/green] {DEPENDABOT_PATH}")
+
+
+def _dependabot(root: Path, platform: str) -> Optional[str]:
+    """.github/dependabot.yml as quoll writes it for the current members (GitHub only)."""
+    if platform != "github" or not (root / DEPENDABOT_PATH).exists():
+        return None
+    repo = load_repo(root)
+    docker = [m.directory for m in repo.members if (root / m.directory / "Dockerfile").exists()]
+    return render_dependabot(repo, docker)
+
+
+def remove_empty_parents(root: Path, path: Path) -> None:
+    directory = path.parent
+    while directory != root and directory.is_dir() and not any(directory.iterdir()):
+        directory.rmdir()
+        directory = directory.parent

quoll/commands/add.py

@@ -0,0 +1,104 @@
+"""`quoll add service`: a new project in an existing workspace, wired into its CI, compose.yaml and delivery."""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from quoll import platforms
+from quoll.cd.config import load_config as load_cd_config
+from quoll.ci.config import save_config
+from quoll.ci.detect import configured_platform, default_config, detect
+from quoll.commands import cd as cd_command
+from quoll.commands import k8s as k8s_command
+from quoll.commands._common import DirOption, resolve_dir
+from quoll.commands._workspace import Snapshot, refresh, snapshot
+from quoll.commands.new import SERVICES_DIRECTORY, Part, create_part, docker_init, parse_service, quiet
+from quoll.config import quoll_toml
+from quoll.config.quoll_toml import ConfigError
+from quoll.console import console
+from quoll.k8s.config import load_config as load_k8s_config
+from quoll.workspace import (
+    RepoCIConfig,
+    WorkspaceConfig,
+    find_root,
+    load_workspace,
+    member_name,
+    save_workspace,
+)
+
+app = typer.Typer(help="Add a project to a workspace.", no_args_is_help=True)
+
+
+@app.command()
+def service(
+    spec: str = typer.Argument(..., help="NAME=STARTER[@VERSION], e.g. orders=express or orders=express@4."),
+    project_dir: Path = DirOption,
+    within: str = typer.Option(SERVICES_DIRECTORY, "--in", help="Directory holding the services."),
+    node: Optional[str] = typer.Option(None, "--node", help="Node.js version, e.g. 20."),
+) -> None:
+    """Create a service in services/<name>, and add it to the workspace's CI, compose.yaml and delivery."""
+    root = find_root(resolve_dir(project_dir))
+    try:
+        workspace = load_workspace(root)
+    except ConfigError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    data = quoll_toml.read(root)
+    if workspace is None and "project" in data and "stack" in data["project"]:
+        console.print(
+            "[red]Error:[/red] this repository is a single project: a workspace keeps each project in a directory "
+            "of its own (move it, e.g. to back/, then run `quoll ci init`)."
+        )
+        raise typer.Exit(1)
+
+    name, starter, version = parse_service(spec)
+    directory = f"{within.strip('/')}/{name}" if within.strip("/") else name
+    members = list(workspace.members) if workspace else []
+    if directory in members or member_name(directory) in {member_name(m) for m in members}:
+        console.print(f"[red]Error:[/red] the workspace already has a project named {name}.")
+        raise typer.Exit(1)
+    if (root / directory).exists() and any((root / directory).iterdir()):
+        console.print(f"[red]Error:[/red] {directory} exists and isn't empty.")
+        raise typer.Exit(1)
+
+    platform = configured_platform(root) or platforms.detect(root, platforms.remote(root))
+    before = snapshot(root, platform) if workspace else Snapshot(set(), None)
+    with Progress(SpinnerColumn(), TextColumn("{task.description}"), console=console) as progress:
+        notes = create_part(root, root.name, Part(directory, starter, version, name), {"node": node or ""}, progress)
+        quiet("Docker", docker_init(root / directory), progress)
+
+        task = progress.add_task("Adding it to the workspace...")
+        det = detect(root / directory)
+        det.platform = platform
+        save_config(root / directory, default_config(det))
+        if workspace is None:
+            save_workspace(root, [directory], RepoCIConfig(platform=platform))
+        else:
+            quoll_toml.save_section(root, "workspace", WorkspaceConfig(members=[*members, directory]))
+        progress.update(task, description=f"[green]✓[/green] {directory} added to the workspace")
+
+        # The delivery too, when the workspace already publishes images.
+        if any("cd" in quoll_toml.read(root / m) for m in members):
+            reference = next(load_cd_config(root / m) for m in members if "cd" in quoll_toml.read(root / m))
+            quiet("CD", lambda: cd_command._configure(
+                root / directory, root, member_name(directory), yes=True, force=False, platform=platform,
+                registry=reference.registry, image=None,
+            ), progress)
+
+        # And its chart, deployed with the others: same namespaces.
+        charted = [m for m in members if "k8s" in quoll_toml.read(root / m)]
+        if charted:
+            like = load_k8s_config(root / charted[0])
+            quiet("Kubernetes", lambda: k8s_command._init(root, root / directory, yes=True, force=False, like=like),
+                  progress)
+
+    refresh(root, platform, before, f"add {name} to it yourself")
+
+    for note in notes:
+        console.print(f"[yellow]![/yellow] {note}")
+    console.print(f"\n[bold green]✓ {name}[/bold green] is in {directory}/ — reachable from the others at "
+                  f"[bold]{name.upper().replace('-', '_')}_URL[/bold]. Run everything:")
+    console.print("  docker compose up --build")

quoll/commands/add_secret.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from quoll import platforms
+from quoll.ci.detect import configured_platform
+from quoll.commands._common import check_platform, ensure_token, platform_option
+from quoll.console import console
+from quoll.platforms import PlatformError
+
+app = typer.Typer(help="Add a secret to the GitHub/GitLab repository and the local .env file.")
+
+
+@app.callback(invoke_without_command=True)
+def add_secret(
+    repo: Optional[str] = typer.Option(
+        None, "--repo", "-r", help="Repository: name or owner/name (default: the git remote)."
+    ),
+    key: str = typer.Option(..., "--key", "-k", help="Secret name"),
+    value: str = typer.Option(..., "--value", "-v", help="Secret value", hide_input=True),
+    env_file: Path = typer.Option(Path(".env"), "--env-file", help="Path to local .env file"),
+    platform: Optional[str] = platform_option(),
+    local: bool = typer.Option(False, "--local", "--skip-github", help="Only update local .env"),
+) -> None:
+    """Add a secret to GitHub Actions secrets / GitLab CI/CD variables and the local .env file."""
+    check_platform(platform)
+
+    # --- Local .env ---
+    _write_env(env_file, key, value)
+    console.print(f"[green]✓[/green] Added {key} to {env_file}")
+
+    if local:
+        return
+
+    # --- Repository ---
+    project_dir = Path(".")
+    remote = platforms.remote(project_dir)
+    target = platforms.get(platform or configured_platform(project_dir) or platforms.detect(project_dir, remote))
+    repo = repo or (remote.path if remote else None)
+    if not repo:
+        console.print("[red]Error:[/red] no git remote found — pass --repo.")
+        raise typer.Exit(1)
+    host = remote.host if remote and platforms.hosting(remote) == target.name else None
+    if not ensure_token(target.name, host):
+        raise typer.Exit(1)
+
+    try:
+        target.api(host).set_secrets(repo, {key: value})
+        console.print(f"[green]✓[/green] Added {key} to {target.label} repo '{repo}'")
+    except PlatformError as e:
+        console.print(f"[red]{target.label} error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+def _write_env(env_file: Path, key: str, value: str) -> None:
+    lines: list[str] = []
+
+    if env_file.exists():
+        lines = env_file.read_text().splitlines()
+
+    # Update existing key or append
+    key_found = False
+    for i, line in enumerate(lines):
+        if line.startswith(f"{key}=") or line.startswith(f"{key} ="):
+            lines[i] = f"{key}={value}"
+            key_found = True
+            break
+
+    if not key_found:
+        lines.append(f"{key}={value}")
+
+    env_file.write_text("\n".join(lines) + "\n")

quoll/commands/cd.py

@@ -0,0 +1,214 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List, Optional, Union
+
+import questionary
+import typer
+from rich.table import Table
+
+from quoll import platforms
+from quoll.cd.config import CONFIG_FILE, CDConfig, ConfigError, save_config
+from quoll.ci.detect import configured_platform, default_branch
+from quoll.commands._common import (
+    DirOption,
+    ask,
+    check_files,
+    check_platform,
+    confirm_overwrite,
+    platform_option,
+    resolve_dir,
+    update_files,
+)
+from quoll.config import quoll_toml
+from quoll.console import console
+from quoll.files import PlannedFile, write
+from quoll.platforms.gitlab.ci import CD_PATH, PIPELINE_PATH
+from quoll.workspace import Delivery, find_root, load_deliveries, load_workspace, member_name
+
+app = typer.Typer(help="Generate and maintain the delivery pipeline: build, scan, push.", no_args_is_help=True)
+
+
+@app.command()
+def init(
+    project_dir: Path = DirOption,
+    yes: bool = typer.Option(False, "--yes", "-y", help="Accept the defaults without asking."),
+    force: bool = typer.Option(False, "--force", help="Overwrite a pipeline that was not generated by quoll."),
+    platform: Optional[str] = platform_option(),
+    registry: Optional[str] = typer.Option(
+        None, help="ghcr (GitHub) or gitlab (GitLab) — the default —, or dockerhub."
+    ),
+    image: Optional[str] = typer.Option(None, help="Image name, e.g. ghcr.io/acme/api."),
+) -> None:
+    """Write [cd] in quoll.toml and generate the delivery pipeline.
+
+    At the root of a workspace: for each of its projects with a Dockerfile; in one of its projects: for it."""
+    project_dir = resolve_dir(project_dir)
+    check_platform(platform)
+    root = find_root(project_dir)
+    try:
+        workspace = load_workspace(root)
+    except ConfigError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    if workspace is None:
+        cfg = _configure(project_dir, root, "", yes=yes, force=force, platform=platform, registry=registry,
+                         image=image)
+        if cfg is None:
+            raise typer.Exit(0)
+        deliveries: List[Delivery] = [Delivery("", ".", cfg)]
+    else:
+        if project_dir == root:
+            members = [m for m in workspace.members if (root / m / "Dockerfile").exists()]
+            for m in workspace.members:
+                if m not in members:
+                    console.print(f"[yellow]![/yellow] {m}: no Dockerfile — run [bold]quoll docker init[/bold] first.")
+        else:
+            members = [project_dir.relative_to(root).as_posix()]
+        if image and len(members) > 1:
+            console.print("[red]Error:[/red] --image names one image: run `quoll cd init` in each project directory.")
+            raise typer.Exit(1)
+        for member in members:
+            _configure(root / member, root, member_name(member), yes=yes, force=force, platform=platform,
+                       registry=registry, image=image)
+        deliveries = _deliveries(root)
+
+    cfg = deliveries[0].cfg
+    files = _plan(root, deliveries)
+    if not confirm_overwrite(files, yes=yes, force=force):
+        raise typer.Exit(1)
+    for delivery in deliveries:
+        save_config(root / delivery.directory, delivery.cfg)
+    write(root, files)
+    console.print()
+    for f in files:
+        console.print(f"[green]✓[/green] {f.path}")
+
+    for delivery in deliveries:
+        console.print(f"\n[bold green]Done![/bold green] Every push to {', '.join(delivery.cfg.branches)} and every v* "
+                      f"tag now publishes {delivery.cfg.image}.")
+    target = platforms.get(cfg.platform)
+    secrets = sorted({s for d in deliveries for s in target.registry_secrets(d.cfg.registry)})
+    if secrets:
+        names = " and ".join(f"[bold]{s}[/bold]" for s in secrets)
+        console.print(f"Set the {names} {target.label} {target.secrets_label}.")
+    if cfg.platform == "gitlab":
+        _check_gitlab_include(root)
+
+
+def _configure(
+    project_dir: Path,
+    root: Path,
+    member: str,
+    *,
+    yes: bool,
+    force: bool,
+    platform: Optional[str],
+    registry: Optional[str],
+    image: Optional[str],
+) -> Optional[CDConfig]:
+    """The [cd] of one project, asked or defaulted; saved in its quoll.toml. None when kept as it was."""
+    console.print(f"\n[bold]quoll cd[/bold] — {member or project_dir.name}\n")
+    if "cd" in _read(project_dir) and not force:
+        if yes or not ask(questionary.confirm(f"{CONFIG_FILE} already configures CD. Replace it?", default=False)):
+            console.print("Kept. Use [bold]quoll cd update[/bold] to regenerate from quoll.toml.")
+            return None
+    if not (project_dir / "Dockerfile").exists():
+        console.print("[yellow]![/yellow] No Dockerfile yet — run [bold]quoll docker init[/bold] first.")
+
+    remote = platforms.remote(root)
+    name = platform or configured_platform(project_dir) or configured_platform(root) or platforms.detect(root, remote)
+    target = platforms.get(name)
+    registries = target.registries
+    if registry is None:
+        registry = registries[0] if yes else ask(
+            questionary.select("Registry", choices=list(registries), default=registries[0])
+        )
+    if registry not in registries:
+        console.print(
+            f"[red]Error:[/red] unknown registry '{registry}' for {target.label} "
+            f"(expected one of: {', '.join(registries)})."
+        )
+        raise typer.Exit(1)
+    default_image = target.default_image(remote, registry, root.name, member)
+    if image is None:
+        image = default_image if yes else ask(questionary.text("Image", default=default_image))
+
+    note = " (private GitHub repositories need GitHub Enterprise Cloud)" if name == "github" else ""
+    sign = True if yes else ask(questionary.confirm(f"Sign the image and its SBOM with Sigstore{note}?", default=True))
+
+    try:
+        cfg = CDConfig(
+            platform=name, registry=registry, image=image.lower(), branches=[default_branch(root)], sign=sign
+        )
+    except ValueError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+    _print_config(cfg)
+    if member:
+        save_config(project_dir, cfg)
+    return cfg
+
+
+@app.command()
+def update(
+    project_dir: Path = DirOption,
+    yes: bool = typer.Option(False, "--yes", "-y", help="Write changes without asking."),
+    force: bool = typer.Option(False, "--force", help="Overwrite a pipeline that was not generated by quoll."),
+) -> None:
+    """Regenerate the delivery workflow from quoll.toml (the workspace's, from any of its directories)."""
+    root = find_root(resolve_dir(project_dir))
+    update_files(root, _plan(root, _deliveries(root)), yes=yes, force=force, what="CD is")
+
+
+@app.command()
+def check(project_dir: Path = DirOption) -> None:
+    """Fail if the delivery pipeline differs from what quoll.toml describes."""
+    root = find_root(resolve_dir(project_dir))
+    check_files(_plan(root, _deliveries(root)), "cd")
+
+
+def _plan(root: Path, deliveries: List[Delivery]) -> List[PlannedFile]:
+    target: Union[CDConfig, List[Delivery]] = deliveries[0].cfg if not deliveries[0].name else deliveries
+    return platforms.get(deliveries[0].cfg.platform).cd_files(root, target)
+
+
+def _deliveries(root: Path) -> List[Delivery]:
+    try:
+        return load_deliveries(root)
+    except ConfigError as e:
+        console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(1)
+
+
+def _check_gitlab_include(project_dir: Path) -> None:
+    """.gitlab/cd.yml only runs when .gitlab-ci.yml includes it, as quoll's does."""
+    pipeline = project_dir / PIPELINE_PATH
+    if pipeline.exists() and CD_PATH in pipeline.read_text():
+        return
+    if not pipeline.exists():
+        console.print("[yellow]![/yellow] No .gitlab-ci.yml yet — run [bold]quoll ci init[/bold], which includes "
+                      f"{CD_PATH}.")
+    else:
+        console.print(f"[yellow]![/yellow] Add {CD_PATH} to your .gitlab-ci.yml (and a `publish` stage after the "
+                      f"tests):\n  include:\n    - local: {CD_PATH}")
+
+
+def _print_config(cfg: CDConfig) -> None:
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column(style="dim")
+    table.add_column(style="bold")
+    table.add_row("Image", cfg.image)
+    table.add_row("Published on", ", ".join([*cfg.branches, *(["v* tags"] if cfg.release_tags else [])]))
+    table.add_row("Scan", f"Trivy, blocks on {', '.join(cfg.severity)}" if cfg.scan else "off")
+    table.add_row("Platforms", ", ".join(cfg.platforms))
+    table.add_row("SBOM", "artifact + release asset" if cfg.sbom else "off")
+    table.add_row("Signature", "Sigstore" if cfg.sign else "off")
+    console.print(table)
+
+
+def _read(project_dir: Path) -> dict:
+    try:
+        return quoll_toml.read(project_dir)
+    except ConfigError:
+        return {}