eggpipe 0.3.0__py3-none-any.whl

eggpipe/cli/main.py

@@ -0,0 +1,710 @@
+"""Eggpipe command-line interface."""
+
+from __future__ import annotations
+
+import functools
+import json
+import sys
+import warnings
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Annotated, Any, ParamSpec, TypeVar
+
+import typer
+
+from eggpipe.config.app_config import AppConfig
+from eggpipe.config.logging import setup_logging
+from eggpipe.config.project_config import ProjectConfig, ProjectConfigLoader
+from eggpipe.core.discovery import discover_sources
+from eggpipe.core.document import ModelDocument
+from eggpipe.core.format_registry import FormatRegistry
+from eggpipe.core.parser import Parser
+from eggpipe.core.validator import validate_document
+from eggpipe.engine.artifact_writer import ArtifactWriter
+from eggpipe.engine.engine import Engine
+from eggpipe.engine.plugin_loader import (
+    GENERATOR_GROUP,
+    PluginIssue,
+    build_format_registry_with_issues,
+    load_generators_with_issues,
+    load_local_generators_with_issues,
+)
+from eggpipe.engine.policy import DiagnosticPolicy
+from eggpipe.engine.report import EngineReport
+from eggpipe.interfaces.generator import GeneratorPlugin
+from eggpipe.utils.exceptions import (
+    ConfigValidationError,
+    DocumentError,
+    EggpipeError,
+)
+from eggpipe.version import __version__
+from eggpipe.watch.watcher import run_watch
+
+app = typer.Typer(no_args_is_help=True, add_completion=False, help="Eggpipe")
+config_app = typer.Typer(no_args_is_help=True, help="Configuration")
+model_app = typer.Typer(no_args_is_help=True, help="Models")
+gen_app = typer.Typer(no_args_is_help=True, help="Generators")
+format_app = typer.Typer(no_args_is_help=True, help="Formats")
+app.add_typer(config_app, name="config")
+app.add_typer(model_app, name="model")
+app.add_typer(gen_app, name="gen")
+app.add_typer(format_app, name="format")
+
+ConfigOption = Annotated[
+    Path | None,
+    typer.Option("--config", "-c", help="Path to .eggpipe.yaml"),
+]
+GeneratorOption = Annotated[
+    list[str] | None,
+    typer.Option("--generator", "-g", help="Generators: comma-separated or repeated"),
+]
+
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def command_errors(func: Callable[P, R]) -> Callable[P, R]:
+    @functools.wraps(func)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        try:
+            return func(*args, **kwargs)
+        except DocumentError as exc:
+            typer.echo(f"error: {exc}", err=True)
+            raise typer.Exit(code=1) from exc
+        except (ConfigValidationError, EggpipeError) as exc:
+            typer.echo(f"error: {exc}", err=True)
+            raise typer.Exit(code=2) from exc
+        except KeyboardInterrupt as exc:
+            raise typer.Exit(code=130) from exc
+
+    return wrapper
+
+
+@dataclass(frozen=True)
+class ReportOptions:
+    output_format: str
+    quiet: bool
+    verbose: bool
+    strict: bool
+    ignore: str | None
+    json_lines: bool = False
+
+
+@dataclass(frozen=True)
+class RunOptions:
+    models: list[Path] | None
+    config: Path | None
+    generator: list[str] | None
+    plugins: list[Path] | None
+    output: Path | None
+    variables: list[str] | None
+    plan: bool
+    check: bool
+    force: bool
+    strict: bool
+    include_disabled: bool
+    allow_outside_imports: bool
+    clean: bool
+    output_format: str
+    ignore: str | None
+    quiet: bool
+    verbose: bool
+
+
+def _load_rules(config_path: Path | None) -> tuple[ProjectConfig, Path]:
+    path = config_path or ProjectConfigLoader.discover()
+    if path is None:
+        raise ConfigValidationError(".eggpipe.yaml not found; pass --config")
+    rules = ProjectConfigLoader().load(path)
+    return rules, path.resolve().parent
+
+
+def _selected_generators(values: list[str] | None) -> set[str] | None:
+    if not values:
+        return None
+    result: set[str] = set()
+    for value in values:
+        result.update(item.strip() for item in value.split(",") if item.strip())
+    return result or None
+
+
+def _filter_rules(rules: ProjectConfig, selected: set[str] | None) -> ProjectConfig:
+    if selected is None:
+        return rules
+    known = {item.id for item in rules.generators}
+    unknown = selected - known
+    if unknown:
+        raise ConfigValidationError(f"unknown generators: {', '.join(sorted(unknown))}")
+    return rules.model_copy(
+        update={"generators": tuple(item for item in rules.generators if item.id in selected)}
+    )
+
+
+def _parse_variables(values: list[str] | None) -> dict[str, str]:
+    result: dict[str, str] = {}
+    for item in values or []:
+        key, separator, value = item.partition("=")
+        if not separator or not key:
+            raise ConfigValidationError(f"invalid --var: {item!r}")
+        result[key] = value
+    return result
+
+
+def _print_plugin_issues(issues: list[PluginIssue]) -> None:
+    for issue in issues:
+        typer.echo(f"warning: {issue.entry_point}: {issue.message}", err=True)
+
+
+def _load_generators(plugins: list[Path] | None) -> dict[str, GeneratorPlugin]:
+    loaded, issues = load_generators_with_issues()
+    _print_plugin_issues(issues)
+    generators = dict(loaded)
+    if plugins:
+        local, local_issues = load_local_generators_with_issues(plugins)
+        _print_plugin_issues(local_issues)
+        generators.update(local)
+    return generators
+
+
+def _load_format_registry() -> FormatRegistry:
+    registry, issues = build_format_registry_with_issues()
+    _print_plugin_issues(issues)
+    return registry
+
+
+def _print_report(report: EngineReport, options: ReportOptions) -> int:
+    ignored = frozenset(item.strip() for item in (options.ignore or "").split(",") if item.strip())
+    diagnostics = DiagnosticPolicy(
+        ignore=ignored,
+        strict=options.strict,
+    ).apply(report.diagnostics)
+    warnings = [item for item in diagnostics if item.level == "warning"]
+    errors = [item for item in diagnostics if item.level == "error"]
+    success = (
+        not errors
+        and all(generator.status != "error" for generator in report.generators)
+        and not (options.strict and warnings)
+    )
+    exit_code = 0 if success else (2 if report.exit_code == 2 else 1)
+    report = report.model_copy(
+        update={"diagnostics": diagnostics, "success": success, "exit_code": exit_code}
+    )
+
+    if options.output_format == "json":
+        payload = report.model_dump(mode="json")
+        if options.json_lines:
+            typer.echo(json.dumps(payload, ensure_ascii=False))
+        else:
+            typer.echo(json.dumps(payload, ensure_ascii=False, indent=2))
+        return exit_code
+
+    for item in diagnostics:
+        if item.level == "error" or options.verbose or not options.quiet:
+            location = _location(item.location)
+            typer.echo(f"{item.level}: {item.code}: {item.message}{location}", err=True)
+    if not options.quiet:
+        for generator in report.generators:
+            typer.echo(f"[{generator.status}] {generator.id} ({generator.duration_ms} ms)")
+        if options.verbose:
+            for artifact in report.artifacts:
+                typer.echo(f"  {artifact.action}: {artifact.path}")
+        typer.echo("OK" if success else "FAILED")
+    return exit_code
+
+
+def _location(location: Any) -> str:
+    if location is None:
+        return ""
+    parts = [str(value) for value in (location.file, location.entity, location.field) if value]
+    return f" ({':'.join(parts)})" if parts else ""
+
+
+def _run_engine(options: RunOptions) -> None:
+    if options.output_format not in {"text", "json"}:
+        raise ConfigValidationError("--output-format must be text or json")
+    rules, config_dir = _load_rules(options.config)
+    rules = _filter_rules(rules, _selected_generators(options.generator))
+    app_config = AppConfig(
+        rules_file=options.config,
+        output_root=options.output,
+        force=options.force,
+        include_disabled=options.include_disabled,
+        allow_outside_imports=options.allow_outside_imports,
+        clean=options.clean,
+        quiet=options.quiet,
+        verbose=options.verbose,
+    )
+    setup_logging(app_config)
+    engine = Engine(
+        app_config,
+        rules,
+        config_dir=config_dir,
+        source_paths=options.models,
+        variables=_parse_variables(options.variables),
+        generators=_load_generators(options.plugins),
+        formats=_load_format_registry(),
+    )
+    if options.check:
+        report = engine.check()
+    elif options.plan:
+        report = engine.build()
+    else:
+        report = engine.generate()
+    code = _print_report(
+        report,
+        ReportOptions(
+            output_format=options.output_format,
+            quiet=options.quiet,
+            verbose=options.verbose,
+            strict=options.strict,
+            ignore=options.ignore,
+        ),
+    )
+    raise typer.Exit(code=code)
+
+
+@app.command()
+@command_errors
+def generate(
+    models: Annotated[
+        list[Path] | None, typer.Argument(help="Models (defaults to sources)")
+    ] = None,
+    config: ConfigOption = None,
+    generator: GeneratorOption = None,
+    plugin: Annotated[list[Path] | None, typer.Option("--plugin")] = None,
+    output: Annotated[Path | None, typer.Option("--output", "-o")] = None,
+    variable: Annotated[list[str] | None, typer.Option("--var")] = None,
+    dry_run: Annotated[bool, typer.Option("--dry-run")] = False,
+    plan: Annotated[bool, typer.Option("--plan")] = False,
+    check: Annotated[bool, typer.Option("--check")] = False,
+    force: Annotated[bool, typer.Option("--force")] = False,
+    strict: Annotated[bool, typer.Option("--strict")] = False,
+    include_disabled: Annotated[bool, typer.Option("--include-disabled")] = False,
+    allow_outside_imports: Annotated[bool, typer.Option("--allow-outside-imports")] = False,
+    clean: Annotated[bool, typer.Option("--clean")] = False,
+    output_format: Annotated[str, typer.Option("--output-format")] = "text",
+    ignore: Annotated[str | None, typer.Option("--ignore")] = None,
+    quiet: Annotated[bool, typer.Option("--quiet", "-q")] = False,
+    verbose: Annotated[bool, typer.Option("--verbose", "-v")] = False,
+    no_color: Annotated[bool, typer.Option("--no-color")] = False,
+) -> None:
+    """Generate artifacts."""
+    del no_color
+    _run_engine(
+        RunOptions(
+            models=models,
+            config=config,
+            generator=generator,
+            plugins=plugin,
+            output=output,
+            variables=variable,
+            plan=plan or dry_run,
+            check=check,
+            force=force,
+            strict=strict,
+            include_disabled=include_disabled,
+            allow_outside_imports=allow_outside_imports,
+            clean=clean,
+            output_format=output_format,
+            ignore=ignore,
+            quiet=quiet,
+            verbose=verbose,
+        )
+    )
+
+
+@app.command()
+def init(
+    path: Annotated[Path, typer.Argument()] = Path(".eggpipe.yaml"),
+    force: Annotated[bool, typer.Option("--force")] = False,
+    layout: Annotated[str | None, typer.Option("--layout")] = None,
+) -> None:
+    """Create a minimal .eggpipe.yaml and an example model."""
+    if layout is None:
+        if not sys.stdin.isatty():
+            typer.echo("error: --layout is required in non-tty mode", err=True)
+            raise typer.Exit(code=2)
+        layout = typer.prompt(
+            "layout",
+            default="monolith",
+            type=str,
+        )
+    if layout not in {"monolith", "file-per-model", "directory-per-model"}:
+        typer.echo(f"error: unknown layout: {layout}", err=True)
+        raise typer.Exit(code=2)
+    if path.exists() and not force:
+        typer.echo(f"error: {path} already exists; use --force", err=True)
+        raise typer.Exit(code=2)
+    path.write_text(_default_config(layout), encoding="utf-8")
+    model_path = _default_model(path.parent, layout, force=force)
+    typer.echo(f"created {path}")
+    if model_path is not None:
+        typer.echo(f"created {model_path}")
+
+
+def _default_model(base: Path, layout: str, *, force: bool) -> Path | None:
+    text = (
+        'format: entity-model\nversion: "1.0"\nmodel:\n'
+        "  entities:\n    - name: User\n      fields:\n"
+        "        - name: id\n          type: integer\n          required: true\n"
+        "          description: Identifier\n"
+    )
+    if layout == "monolith":
+        target = base / "model.yaml"
+    elif layout == "file-per-model":
+        target = base / "models" / "user.yaml"
+    else:
+        target = base / "models" / "user" / "base.yaml"
+    if target.exists() and not force:
+        return None
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(text, encoding="utf-8")
+    return target
+
+
+def _default_config(layout: str) -> str:
+    if layout == "monolith":
+        source = "  - path: ./model.yaml\n    layout: monolith\n"
+    elif layout == "file-per-model":
+        source = '  - path: ./models\n    layout: file-per-model\n    files: ["*.yaml"]\n'
+    else:
+        source = (
+            "  - path: ./models\n"
+            "    layout: directory-per-model\n"
+            '    model_dirs: ["*"]\n'
+            '    files: ["*.yaml"]\n'
+        )
+    return f'version: "1.0"\nsources:\n{source}generators: []\n'
+
+
+@app.command()
+@command_errors
+def watch(
+    models: Annotated[
+        list[Path] | None, typer.Argument(help="Models (defaults to sources)")
+    ] = None,
+    config: ConfigOption = None,
+    generator: GeneratorOption = None,
+    plugin: Annotated[list[Path] | None, typer.Option("--plugin")] = None,
+    output: Annotated[Path | None, typer.Option("--output", "-o")] = None,
+    variable: Annotated[list[str] | None, typer.Option("--var")] = None,
+    strict: Annotated[bool, typer.Option("--strict")] = False,
+    include_disabled: Annotated[bool, typer.Option("--include-disabled")] = False,
+    allow_outside_imports: Annotated[bool, typer.Option("--allow-outside-imports")] = False,
+    force: Annotated[bool, typer.Option("--force")] = False,
+    output_format: Annotated[str, typer.Option("--output-format")] = "text",
+    ignore: Annotated[str | None, typer.Option("--ignore")] = None,
+    quiet: Annotated[bool, typer.Option("--quiet", "-q")] = False,
+    verbose: Annotated[bool, typer.Option("--verbose", "-v")] = False,
+    no_color: Annotated[bool, typer.Option("--no-color")] = False,
+    debounce: Annotated[int, typer.Option("--debounce-ms", "--debounce")] = 300,
+) -> None:
+    """Watch mode: regenerate when sources change."""
+    del no_color
+    path = config or ProjectConfigLoader.discover()
+    if path is None:
+        raise ConfigValidationError(".eggpipe.yaml not found; pass --config")
+    path = path.resolve()
+    rules, config_dir = _load_rules(path)
+    rules = _filter_rules(rules, _selected_generators(generator))
+    generators = _load_generators(plugin)
+    formats = _load_format_registry()
+    output_root = (output or config_dir).resolve()
+    source_paths = [
+        item if item.is_absolute() else (config_dir / item).resolve()
+        for item in (models or [source.path for source in rules.sources])
+    ]
+    discovered = discover_sources(
+        rules,
+        config_dir,
+        allow_outside=allow_outside_imports,
+    )
+    resource_paths = [item.path for item in discovered.resources.values()]
+    ignored_dirs = {(output_root / item.output_dir).resolve() for item in rules.generators}
+
+    def run_once() -> int:
+        current_rules, current_dir = _load_rules(path)
+        current_rules = _filter_rules(current_rules, _selected_generators(generator))
+        app_config = AppConfig(
+            rules_file=path,
+            output_root=output,
+            force=force,
+            include_disabled=include_disabled,
+            allow_outside_imports=allow_outside_imports,
+            quiet=quiet,
+            verbose=verbose,
+        )
+        setup_logging(app_config)
+        engine = Engine(
+            app_config,
+            current_rules,
+            config_dir=current_dir,
+            source_paths=models,
+            variables=_parse_variables(variable),
+            generators=generators,
+            formats=formats,
+        )
+        report = engine.generate()
+        return _print_report(
+            report,
+            ReportOptions(
+                output_format=output_format,
+                quiet=quiet,
+                verbose=verbose,
+                strict=strict,
+                ignore=ignore,
+                json_lines=True,
+            ),
+        )
+
+    run_watch(
+        config_path=path,
+        source_paths=[*source_paths, *resource_paths],
+        ignored_dirs=ignored_dirs,
+        debounce_ms=debounce,
+        run_once=run_once,
+    )
+
+
+@config_app.command("show")
+@command_errors
+def config_show(
+    config: ConfigOption = None,
+    output: Annotated[Path | None, typer.Option("--output", "-o")] = None,
+    show_secrets: Annotated[bool, typer.Option("--show-secrets")] = False,
+) -> None:
+    """Show the merged config and resolved paths."""
+    rules, config_dir = _load_rules(config)
+    data = rules.model_dump(mode="json", by_alias=True)
+    if not show_secrets:
+        data["variables"] = _redact(data.get("variables", {}))
+    discovered = discover_sources(rules, config_dir)
+    base = (output or config_dir).resolve()
+    data["resolved"] = {
+        "config_dir": str(config_dir),
+        "sources": [str(path) for path in discovered.paths],
+        "source_diagnostics": [item.model_dump(mode="json") for item in discovered.diagnostics],
+        "output_root": str(base),
+        "generators": [
+            {
+                "id": item.id,
+                "output_dir": str((base / item.output_dir).resolve()),
+            }
+            for item in rules.generators
+        ],
+    }
+    typer.echo(json.dumps(data, ensure_ascii=False, indent=2))
+
+
+@config_app.command("validate")
+@command_errors
+def config_validate(config: ConfigOption = None) -> None:
+    """Validate .eggpipe.yaml and sources."""
+    rules, config_dir = _load_rules(config)
+    discovered = discover_sources(rules, config_dir)
+    for item in discovered.diagnostics:
+        typer.echo(f"{item.level}: {item.code}: {item.message}", err=True)
+    if any(item.level == "error" for item in discovered.diagnostics):
+        raise typer.Exit(code=1)
+    typer.echo("OK")
+
+
+@config_app.command("schema")
+def config_schema(
+    output: Annotated[Path | None, typer.Option("--output")] = None,
+) -> None:
+    """Print the .eggpipe.yaml JSON Schema."""
+    _print_schema(_safe_schema(ProjectConfig), output)
+
+
+def _safe_schema(model: type[Any]) -> dict[str, Any]:
+    # UNSET is not a JSON value; default is excluded from the schema.
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        return model.model_json_schema()
+
+
+def _print_schema(schema: dict[str, Any], output: Path | None) -> None:
+    text = json.dumps(schema, ensure_ascii=False, indent=2)
+    if output is not None:
+        output.write_text(text + "\n", encoding="utf-8")
+        typer.echo(str(output))
+    else:
+        typer.echo(text)
+
+
+def _redact(values: dict[str, str]) -> dict[str, str]:
+    secret_markers = ("token", "secret", "password")
+    return {
+        key: "***" if any(marker in key.lower() for marker in secret_markers) else value
+        for key, value in values.items()
+    }
+
+
+@model_app.command("validate")
+def model_validate(
+    models: Annotated[list[Path], typer.Argument()],
+    output_format: Annotated[str, typer.Option("--output-format")] = "text",
+) -> None:
+    """Validate models."""
+    parser = Parser(_load_format_registry())
+    diagnostics = []
+    for path in models:
+        try:
+            diagnostics.extend(validate_document(parser.parse_document(path)))
+        except DocumentError as exc:
+            typer.echo(f"error: {exc.code}: {exc.message} ({exc.path})", err=True)
+            raise typer.Exit(code=1) from exc
+    if output_format == "json":
+        typer.echo(
+            json.dumps(
+                [item.model_dump(mode="json") for item in diagnostics],
+                ensure_ascii=False,
+                indent=2,
+            )
+        )
+    else:
+        for item in diagnostics:
+            typer.echo(f"{item.level}: {item.code}: {item.message}", err=True)
+        typer.echo("OK" if not any(item.level == "error" for item in diagnostics) else "FAILED")
+    raise typer.Exit(code=0 if not any(item.level == "error" for item in diagnostics) else 1)
+
+
+@model_app.command("schema")
+def model_schema(
+    output: Annotated[Path | None, typer.Option("--output")] = None,
+    format_name: Annotated[str | None, typer.Option("--format")] = None,
+    version: Annotated[str | None, typer.Option("--version")] = None,
+) -> None:
+    """Print the JSON Schema of a model or format document."""
+    if format_name is None:
+        _print_schema(_safe_schema(ModelDocument), output)
+        return
+    registry = _load_format_registry()
+    try:
+        plugin = registry.get(format_name)
+    except EggpipeError as exc:
+        typer.echo(f"error: {exc}", err=True)
+        raise typer.Exit(code=2) from exc
+    resolved = version or plugin.supported_versions[-1]
+    schema = plugin.schemas.get(resolved)
+    if schema is None:
+        typer.echo(f"error: {format_name} does not support version {resolved}", err=True)
+        raise typer.Exit(code=2)
+    _print_schema(
+        {
+            "format": format_name,
+            "version": resolved,
+            "layer_entity": _safe_schema(schema.layer_entity),
+            "full_entity": _safe_schema(schema.full_entity),
+        },
+        output,
+    )
+
+
+@gen_app.command("list")
+def gen_list(
+    show_all: Annotated[bool, typer.Option("--all")] = False,
+) -> None:
+    """List generators from entry points."""
+    plugins, issues = load_generators_with_issues()
+    if show_all:
+        _print_plugin_issues(issues)
+    if not plugins:
+        typer.echo("no generators")
+        return
+    for generator_id, plugin in sorted(plugins.items()):
+        formats = _input_formats_label(plugin.input_formats)
+        typer.echo(
+            f"{generator_id}\t{plugin.name or generator_id}\t"
+            f"api={plugin.api_version}\tinput_formats={formats}"
+        )
+
+
+@gen_app.command("info")
+def gen_info(generator_id: str) -> None:
+    """Show generator information."""
+    plugin = _load_generators(None).get(generator_id)
+    if plugin is None:
+        typer.echo(f"error: unknown generator: {generator_id}", err=True)
+        raise typer.Exit(code=2)
+    typer.echo(f"id: {plugin.id}")
+    typer.echo(f"name: {plugin.name or plugin.id}")
+    typer.echo(f"api_version: {plugin.api_version}")
+    typer.echo(f"input_formats: {_input_formats_label(plugin.input_formats)}")
+    typer.echo(f"entry point group: {GENERATOR_GROUP}")
+
+
+def _input_formats_label(formats: set[str] | None) -> str:
+    if formats is None:
+        return "any"
+    return ",".join(sorted(formats)) if formats else "none"
+
+
+@format_app.command("info")
+def format_info(name: str) -> None:
+    """Show format information."""
+    registry = _load_format_registry()
+    try:
+        plugin = registry.get(name)
+    except EggpipeError as exc:
+        typer.echo(f"error: {exc}", err=True)
+        raise typer.Exit(code=2) from exc
+    typer.echo(f"name: {name}")
+    typer.echo(f"versions: {','.join(plugin.supported_versions)}")
+    typer.echo(f"extends: {plugin.extends or '-'}")
+    typer.echo(f"primitive_types: {','.join(sorted(plugin.primitive_types))}")
+    typer.echo(f"schemas: {','.join(sorted(plugin.schemas))}")
+
+
+@format_app.command("list")
+def format_list() -> None:
+    """List formats."""
+    registry, issues = build_format_registry_with_issues()
+    _print_plugin_issues(issues)
+    for item in registry.list():
+        typer.echo(f"{item.name}\tversions={','.join(item.versions)}")
+
+
+@app.command()
+@command_errors
+def clean(
+    config: ConfigOption = None,
+    root: Annotated[Path | None, typer.Option("--root")] = None,
+    dry_run: Annotated[bool, typer.Option("--dry-run")] = False,
+    yes: Annotated[bool, typer.Option("--yes")] = False,
+) -> None:
+    """Remove unchanged owned artifacts using the global manifest."""
+    if root is not None:
+        config_dir = root.resolve()
+    elif config is not None:
+        config_dir = config.resolve().parent
+    else:
+        config_dir = Path.cwd()
+    if not dry_run and not yes:
+        if not sys.stdin.isatty():
+            typer.echo("error: --yes is required in non-tty mode", err=True)
+            raise typer.Exit(code=2)
+        if not typer.confirm("Remove unchanged owned artifacts?"):
+            return
+    writer = ArtifactWriter(eggpipe_version=__version__, config_dir=config_dir)
+    if not writer.manifest_path.is_file():
+        typer.echo("no manifest")
+        return
+    if dry_run:
+        result = writer.clean(dry_run=True)
+    else:
+        with writer.write_lock():
+            result = writer.clean(dry_run=False)
+    for item in result.diagnostics:
+        typer.echo(f"{item.level}: {item.code}: {item.message}", err=True)
+    action = "planned" if dry_run else "cleaned"
+    typer.echo(
+        f"{action} artifacts: {result.removed_artifacts}, locations: {result.removed_locations}"
+    )
+
+
+if __name__ == "__main__":
+    app()