WP-0001-T014: minimal HTTP app and CLI

src/artifactstore/app.py (new): composition root. build_registry(settings)
wires AsyncEngine + LocalBackend + InProcessDataPlane + RegistryViewWriter
into a Registry. Used by both the HTTP app and the CLI.

src/artifactstore/registry/__init__.py: adds db_health() (SELECT 1 probe),
backend_health() (pass-through to dataplane), and dispose() (engine
shutdown) helpers so the HTTP /health endpoint and CLI commands can talk
to the registry without reaching for private state.

src/artifactstore/api/http/__init__.py:
- create_app(settings=None) factory; lifespan owns the registry instance
  and disposes it on shutdown.
- GET / returns the scaffold banner.
- GET /health reports overall status + db {healthy, detail} + backend
  {backend_id, healthy, detail, free_bytes, total_bytes}. Uses
  FastAPI Depends() with a request->state.registry helper rather than
  reaching app.state directly.
- Module-level `app = create_app()` so `uvicorn artifactstore.api.http:app`
  keeps working.

src/artifactstore/cli/__init__.py:
- migrate: `alembic upgrade head` via the alembic command API.
- replay: drops + rebuilds materialised views from the event log; prints
  the highest applied sequence.
- health: prints the same payload as the HTTP /health endpoint, as JSON.
- version unchanged.

Tests:
- tests/integration/test_http_health.py (TestClient-based): /
  scaffold banner; /health reports ok with db.healthy + backend.healthy
  + free_bytes populated.
- tests/integration/test_cli_commands.py (typer CliRunner): version
  prints; migrate creates the schema (events + retention_classes +
  alembic_version); replay against an empty log exits ok with
  "replayed up to sequence 0"; health prints a status=ok JSON payload.

Gates: ruff clean, mypy --strict clean on 48 files, 83 tests pass.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

src/artifactstore/cli/__init__.py

@@ -1,15 +1,28 @@
 """artifact-store command-line interface.
 
 The CLI is a thin consumer of :mod:`artifactstore.registry` (per ADR-0005).
-The scaffold exposes only ``version``; richer subcommands land in later
-tasks of ARTIFACT-STORE-WP-0001 and follow-on workplans.
+T014 ships ``version``, ``migrate``, ``replay``, and ``health`` subcommands;
+richer subcommands (e.g. ``push``, ``manifest``) land alongside the HTTP API
+in WP-0002.
 """
 
 from __future__ import annotations
 
+import asyncio
+import json
+from pathlib import Path
+from typing import Any
+
 import typer
 
 from artifactstore import __version__
+from artifactstore.config import Settings, get_settings
+from artifactstore.db.engine import create_engine
+from artifactstore.events import RegistryViewWriter
+from artifactstore.events import replay as events_replay
+from artifactstore.registry import Registry
+
+__all__ = ["app"]
 
 app = typer.Typer(
     help="artifact-store: artifact registry and storage gateway",
@@ -19,11 +32,7 @@ app = typer.Typer(
 
 @app.callback()
 def main() -> None:
-    """Top-level CLI entry point.
-
-    Forces typer into multi-command mode so subcommands behave consistently
-    even while the scaffold only ships ``version``.
-    """
+    """Top-level CLI entry point."""
 
 
 @app.command()
@@ -32,5 +41,74 @@ def version() -> None:
     typer.echo(__version__)
 
 
+@app.command()
+def migrate(
+    alembic_ini: Path = typer.Option(
+        Path("alembic.ini"),
+        "--alembic-ini",
+        help="Path to alembic.ini (defaults to the repo root).",
+    ),
+) -> None:
+    """Run ``alembic upgrade head`` against the configured database."""
+    from alembic import command
+    from alembic.config import Config
+
+    cfg = Config(str(alembic_ini))
+    command.upgrade(cfg, "head")
+    typer.echo("alembic upgrade head: ok")
+
+
+@app.command()
+def replay() -> None:
+    """Truncate materialised views and replay every event from sequence 1."""
+    settings = get_settings()
+    last_seq = asyncio.run(_replay_async(settings))
+    typer.echo(f"replayed up to sequence {last_seq}")
+
+
+@app.command()
+def health() -> None:
+    """Print a JSON liveness summary (db, backend)."""
+    settings = get_settings()
+    payload = asyncio.run(_health_async(settings))
+    typer.echo(json.dumps(payload, indent=2))
+
+
+# ---- internals -------------------------------------------------------------
+
+
+async def _replay_async(settings: Settings) -> int:
+    engine = create_engine(settings)
+    try:
+        return await events_replay(engine, RegistryViewWriter(), reset=True)
+    finally:
+        await engine.dispose()
+
+
+async def _health_async(settings: Settings) -> dict[str, Any]:
+    from artifactstore.app import build_registry
+
+    registry: Registry = build_registry(settings)
+    try:
+        db_ok, db_detail = await registry.db_health()
+        backend_status = await registry.backend_health()
+    finally:
+        await registry.dispose()
+    overall = "ok" if db_ok and backend_status.healthy else "degraded"
+    return {
+        "service": "artifact-store",
+        "version": __version__,
+        "status": overall,
+        "db": {"healthy": db_ok, "detail": db_detail},
+        "backend": {
+            "backend_id": backend_status.backend_id,
+            "healthy": backend_status.healthy,
+            "detail": backend_status.detail,
+            "free_bytes": backend_status.free_bytes,
+            "total_bytes": backend_status.total_bytes,
+        },
+    }
+
+
 if __name__ == "__main__":  # pragma: no cover
     app()