fastapi-spawn 0.1.0__py3-none-any.whl

fastapi_spawn/__init__.py

@@ -0,0 +1,6 @@
+"""fastapi-spawn — Production-ready FastAPI project scaffolding CLI."""
+
+__version__ = "0.1.0"
+__author__ = "Bishwajit Garai"
+__email__ = "bishwajitgarai@gmail.com"
+__license__ = "MIT"

fastapi_spawn/cli.py

@@ -0,0 +1,387 @@
+"""Main CLI entry point for fastapi-spawn."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich import print as rprint
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from fastapi_spawn import __version__
+from fastapi_spawn.config import ProjectConfig
+from fastapi_spawn.constants import (
+    AIProvider,
+    AuthType,
+    Broker,
+    Cache,
+    CIProvider,
+    Database,
+    LogLibrary,
+    MigrationTool,
+    ORM,
+    Stack,
+    Storage,
+)
+from fastapi_spawn.generator import ProjectGenerator
+from fastapi_spawn.interactive import run_interactive_flow
+from fastapi_spawn.validators import validate_orm_db_compat, validate_output_dir, validate_project_name
+
+app = typer.Typer(
+    name="fastapi-spawn",
+    help="[bold cyan]fastapi-spawn[/bold cyan] — Scaffold production-ready FastAPI projects in seconds.",
+    add_completion=True,
+    rich_markup_mode="rich",
+    no_args_is_help=True,
+)
+console = Console()
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        rprint(f"[bold cyan]fastapi-spawn[/bold cyan] version [bold]{__version__}[/bold]")
+        raise typer.Exit()
+
+
+# ── `new` command ─────────────────────────────────────────────────────────────
+
+@app.command("new", help="Create a new FastAPI project.")
+def new(
+    project_name: Optional[str] = typer.Argument(None, help="Name of the new project"),
+    db: Optional[Database] = typer.Option(None, "--db", help="Database backend"),
+    orm: Optional[ORM] = typer.Option(None, "--orm", help="ORM / ODM"),
+    migration: Optional[MigrationTool] = typer.Option(None, "--migration", help="Migration tool (alembic, aerich, none)"),
+    auth: Optional[AuthType] = typer.Option(None, "--auth", help="Auth strategy"),
+    broker: Optional[Broker] = typer.Option(None, "--broker", help="Message broker"),
+    cache: Optional[Cache] = typer.Option(None, "--cache", help="Cache layer"),
+    storage: Optional[Storage] = typer.Option(None, "--storage", help="File storage (s3, local, none)"),
+    ai: Optional[AIProvider] = typer.Option(None, "--ai", help="AI provider (openai, anthropic, none)"),
+    stack: Optional[Stack] = typer.Option(None, "--stack", help="Deployment stack"),
+    ci: Optional[CIProvider] = typer.Option(None, "--ci", help="CI/CD provider"),
+    log_lib: Optional[LogLibrary] = typer.Option(None, "--log-lib", help="Logging library"),
+    no_docker: bool = typer.Option(False, "--no-docker", help="Skip Docker files"),
+    no_tests: bool = typer.Option(False, "--no-tests", help="Skip test suite"),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Preview structure without writing files"),
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing directory"),
+    output: Path = typer.Option(Path("."), "--output", "-o", help="Output directory"),
+    version: Optional[bool] = typer.Option(
+        None, "--version", "-v", callback=version_callback, is_eager=True, help="Show version"
+    ),
+) -> None:
+    _print_banner()
+
+    needs_interactive = any(
+        x is None for x in [project_name, db, orm, migration, auth, broker, cache, storage, ai, stack, ci, log_lib]
+    )
+
+    if needs_interactive:
+        console.print("[dim]Some options are missing — launching interactive mode...[/dim]\n")
+        opts = run_interactive_flow(project_name or "")
+        project_name = project_name or opts["project_name"]
+        db = db or opts["db"]
+        orm = orm or opts["orm"]
+        migration = migration or opts["migration"]
+        auth = auth or opts["auth"]
+        broker = broker or opts["broker"]
+        cache = cache or opts["cache"]
+        storage = storage or opts["storage"]
+        ai = ai or opts["ai"]
+        stack = stack or opts["stack"]
+        ci = ci or opts["ci"]
+        log_lib = log_lib or opts["log_lib"]
+        include_docker = (not no_docker) and opts["include_docker"]
+        include_tests = (not no_tests) and opts["include_tests"]
+    else:
+        include_docker = not no_docker
+        include_tests = not no_tests
+
+    # Validate
+    try:
+        validate_project_name(project_name)  # type: ignore[arg-type]
+        validate_orm_db_compat(orm, db)  # type: ignore[arg-type]
+        if not dry_run:
+            validate_output_dir(output / project_name, force)  # type: ignore[operator]
+    except ValueError as exc:
+        console.print(f"[bold red]✗ Error:[/bold red] {exc}")
+        raise typer.Exit(1) from exc
+
+    config = ProjectConfig(
+        project_name=project_name,  # type: ignore[arg-type]
+        db=db,  # type: ignore[arg-type]
+        orm=orm,  # type: ignore[arg-type]
+        migration=migration,  # type: ignore[arg-type]
+        auth=auth,  # type: ignore[arg-type]
+        broker=broker,  # type: ignore[arg-type]
+        cache=cache,  # type: ignore[arg-type]
+        storage=storage,  # type: ignore[arg-type]
+        ai=ai,  # type: ignore[arg-type]
+        stack=stack,  # type: ignore[arg-type]
+        ci=ci,  # type: ignore[arg-type]
+        log_lib=log_lib,  # type: ignore[arg-type]
+        include_docker=include_docker,
+        include_tests=include_tests,
+        dry_run=dry_run,
+        force=force,
+    )
+
+    _print_summary(config)
+
+    if dry_run:
+        console.print("\n[bold yellow]🔍 Dry-run mode — no files will be written.[/bold yellow]\n")
+
+    try:
+        generator = ProjectGenerator(config, output)
+        project_path = generator.generate()
+    except Exception as exc:
+        console.print(f"\n[bold red]✗ Generation failed:[/bold red] {exc}")
+        raise typer.Exit(1) from exc
+
+    if not dry_run:
+        console.print(f"\n[bold green]✓ Project created:[/bold green] {project_path.resolve()}")
+        _print_next_steps(config)
+
+
+# ── `list-templates` command ───────────────────────────────────────────────────
+
+@app.command("list-templates", help="List all available options and compatible combinations.")
+def list_templates() -> None:
+    _print_banner()
+    table = Table(title="Available Options", border_style="cyan", show_lines=True)
+    table.add_column("Flag", style="bold cyan")
+    table.add_column("Choices", style="white")
+
+    table.add_row("--db", ", ".join(d.value for d in Database))
+    table.add_row("--orm", ", ".join(o.value for o in ORM))
+    table.add_row("--migration", ", ".join(m.value for m in MigrationTool))
+    table.add_row("--auth", ", ".join(a.value for a in AuthType))
+    table.add_row("--broker", ", ".join(b.value for b in Broker))
+    table.add_row("--cache", ", ".join(c.value for c in Cache))
+    table.add_row("--storage", ", ".join(s.value for s in Storage))
+    table.add_row("--ai", ", ".join(a.value for a in AIProvider))
+    table.add_row("--stack", ", ".join(s.value for s in Stack))
+    table.add_row("--ci", ", ".join(c.value for c in CIProvider))
+    table.add_row("--log-lib", ", ".join(l.value for l in LogLibrary))
+    console.print(table)
+
+
+# ── `validate` command ─────────────────────────────────────────────────────────
+
+@app.command("validate", help="Validate a .fastapi-spawn.toml config file.")
+def validate_config(
+    config_file: Path = typer.Argument(..., help="Path to .fastapi-spawn.toml"),
+) -> None:
+    if not config_file.exists():
+        console.print(f"[bold red]✗ File not found:[/bold red] {config_file}")
+        raise typer.Exit(1)
+    console.print(f"[bold green]✓ Config file found:[/bold green] {config_file}")
+    console.print("[dim]Full TOML validation coming in a future release.[/dim]")
+
+
+# ── `add` command ────────────────────────────────────────────────────────────
+
+_ADDABLE_FEATURES = {
+    "auth":      "Authentication (JWT / OAuth2 / API Key)",
+    "s3":        "AWS S3 file storage (boto3)",
+    "openai":    "OpenAI integration (chat + embeddings)",
+    "anthropic": "Anthropic Claude integration",
+    "alembic":   "Alembic async database migrations",
+    "celery":    "Celery worker + sample tasks",
+    "redis":     "Redis cache / broker support",
+    "kafka":     "Kafka broker support (aiokafka)",
+    "docker":    "Dockerfile + docker-compose.yml",
+    "ci":        "GitHub Actions CI/CD workflows",
+    "helm":      "Helm chart (infra/helm/)",
+    "terraform": "Terraform scaffold (infra/terraform/)",
+}
+
+
+@app.command(
+    "add",
+    help="Add a feature to an [bold]existing[/bold] fastapi-spawn project.",
+)
+def add_feature(
+    feature: str = typer.Argument(
+        ...,
+        help=f"Feature to add. Choices: {', '.join(_ADDABLE_FEATURES)}",
+    ),
+    project_dir: Path = typer.Option(
+        Path("."),
+        "--dir", "-d",
+        help="Path to the existing project (default: current directory)",
+    ),
+) -> None:
+    _print_banner()
+
+    if feature not in _ADDABLE_FEATURES:
+        console.print(
+            f"[bold red]✗ Unknown feature:[/bold red] '{feature}'\n"
+            f"[dim]Available: {', '.join(_ADDABLE_FEATURES)}[/dim]"
+        )
+        raise typer.Exit(1)
+
+    if not project_dir.exists():
+        console.print(f"[bold red]✗ Directory not found:[/bold red] {project_dir.resolve()}")
+        raise typer.Exit(1)
+
+    console.print(
+        f"[bold cyan]→ Adding feature:[/bold cyan] [bold]{feature}[/bold] — "
+        f"{_ADDABLE_FEATURES[feature]}"
+    )
+    console.print(
+        f"[dim]Target project:[/dim] {project_dir.resolve()}"
+    )
+    console.print()
+
+    # Feature-specific guidance
+    _feature_guidance(feature, project_dir)
+
+
+def _feature_guidance(feature: str, project_dir: Path) -> None:
+    """Print actionable instructions for each addable feature."""
+    steps: list[str] = []
+
+    if feature == "auth":
+        steps = [
+            "Add to pyproject.toml deps: python-jose[cryptography], passlib[bcrypt], python-multipart",
+            "Copy app/core/security.py — run: fastapi-spawn new <name> --auth jwt --dry-run to preview",
+            "Add auth endpoints to app/api/v1/auth.py",
+            "Add ACCESS_TOKEN_EXPIRE_MINUTES, SECRET_KEY to .env",
+        ]
+    elif feature == "s3":
+        steps = [
+            "Add to pyproject.toml deps: boto3>=1.34.0",
+            "Create app/core/storage.py with boto3 helpers",
+            "Add to .env: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_REGION, AWS_S3_BUCKET, AWS_S3_ENDPOINT_URL",
+            "Add to app/core/config.py: AWS_* individual fields + (optional) s3_endpoint property",
+        ]
+    elif feature == "openai":
+        steps = [
+            "Add to pyproject.toml deps: openai>=1.30.0",
+            "Create app/core/ai.py with AsyncOpenAI client",
+            "Add to .env: OPENAI_API_KEY=sk-placeholder, OPENAI_MODEL=gpt-4o, OPENAI_BASE_URL= ",
+        ]
+    elif feature == "anthropic":
+        steps = [
+            "Add to pyproject.toml deps: anthropic>=0.28.0",
+            "Create app/core/ai.py with AsyncAnthropic client",
+            "Add to .env: ANTHROPIC_API_KEY=sk-ant-placeholder, ANTHROPIC_MODEL=claude-3-5-sonnet-20241022",
+        ]
+    elif feature == "alembic":
+        steps = [
+            "Add to pyproject.toml deps: alembic>=1.13.0",
+            "Run: alembic init migrations",
+            "Replace migrations/env.py with async-compatible version",
+            "Add to [tool.uv.scripts]: migrate = 'alembic upgrade head'",
+            "Run: uv run migrate",
+        ]
+    elif feature == "celery":
+        steps = [
+            "Add to pyproject.toml deps: celery[redis]>=5.3.6",
+            "Create tasks/celery_app.py and tasks/sample_tasks.py",
+            "Add to .env: REDIS_HOST, REDIS_PORT, REDIS_DB",
+            "Add to [tool.uv.scripts]: worker = 'celery -A tasks.celery_app worker --loglevel=info'",
+            "Run: uv run worker",
+        ]
+    elif feature == "redis":
+        steps = [
+            "Add to pyproject.toml deps: redis[hiredis]>=5.0.0",
+            "Add to .env: REDIS_HOST, REDIS_PORT, REDIS_PASSWORD, REDIS_DB",
+            "Add redis_url @property to Settings in app/core/config.py",
+        ]
+    elif feature == "kafka":
+        steps = [
+            "Add to pyproject.toml deps: aiokafka>=0.10.0",
+            "Add to .env: KAFKA_HOST=localhost, KAFKA_PORT=9092",
+            "Create tasks/ producer/consumer modules",
+        ]
+    elif feature == "docker":
+        steps = [
+            "Create Dockerfile (uses uv for fast builds)",
+            "Create docker-compose.yml with all services",
+            "Create .dockerignore",
+            "Run: docker compose up --build",
+        ]
+    elif feature == "ci":
+        steps = [
+            "Create .github/workflows/tests.yml (matrix: py3.10, 3.11, 3.12)",
+            "Create .github/workflows/publish.yml (triggered on v* tags)",
+            "Add PYPI_API_TOKEN to GitHub repo secrets",
+        ]
+    elif feature == "helm":
+        steps = [
+            "Create infra/helm/Chart.yaml",
+            "Create infra/helm/values.yaml with replica, image, resource config",
+            "Run: helm install my-release ./infra/helm",
+        ]
+    elif feature == "terraform":
+        steps = [
+            "Create infra/terraform/main.tf (AWS ECR + ECS scaffold)",
+            "Create infra/terraform/variables.tf",
+            "Run: terraform -chdir=infra/terraform init && terraform apply",
+        ]
+
+    if steps:
+        panel_content = "\n".join(f"  [dim]{i+1}.[/dim] {s}" for i, s in enumerate(steps))
+        console.print(
+            Panel(
+                panel_content,
+                title=f"[bold cyan]Steps to add '{feature}'[/bold cyan]",
+                border_style="cyan",
+                padding=(0, 1),
+            )
+        )
+        console.print(
+            "\n[dim]Tip: Re-scaffold with --dry-run to preview exact file contents:[/dim]\n"
+            f"  [bold cyan]fastapi-spawn new <name> --{feature if feature not in ('s3','openai','anthropic','celery','redis','kafka') else 'storage s3 --ai openai'} --dry-run[/bold cyan]"
+        )
+
+
+# ── Helpers ────────────────────────────────────────────────────────────────────
+
+def _print_banner() -> None:
+    console.print(
+        Panel.fit(
+            "[bold cyan]⚡ fastapi-spawn[/bold cyan]  [dim]v{}[/dim]\n"
+            "[dim]Production-ready FastAPI project scaffolding[/dim]".format(__version__),
+            border_style="cyan",
+            padding=(0, 2),
+        )
+    )
+
+
+def _print_summary(config: ProjectConfig) -> None:
+    table = Table(title="Project Configuration", border_style="dim", show_header=False, show_lines=False)
+    table.add_column("Key", style="bold dim")
+    table.add_column("Value", style="cyan")
+    for key, val in config.summary_lines():
+        table.add_row(key, val)
+    console.print(table)
+
+
+def _print_next_steps(config: ProjectConfig) -> None:
+    steps = [
+        f"  [bold cyan]cd {config.project_name}[/bold cyan]",
+        "  [bold cyan]uv sync[/bold cyan]",
+    ]
+    if config.has_alembic:
+        steps.append("  [bold cyan]uv run alembic upgrade head[/bold cyan]")
+    if config.has_docker:
+        steps.append("  [bold cyan]docker compose up --build[/bold cyan]")
+    else:
+        steps.append("  [bold cyan]uv run main.py[/bold cyan]")
+
+    console.print(
+        Panel(
+            "\n".join(steps),
+            title="[bold green]Next Steps[/bold green]",
+            border_style="green",
+            padding=(0, 1),
+        )
+    )
+
+
+if __name__ == "__main__":
+    app()

fastapi_spawn/config.py

@@ -0,0 +1,162 @@
+"""Project configuration dataclass for fastapi-spawn."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from fastapi_spawn.constants import (
+    AIProvider,
+    AuthType,
+    Broker,
+    Cache,
+    CIProvider,
+    Database,
+    LogLibrary,
+    MigrationTool,
+    ORM,
+    Stack,
+    Storage,
+)
+
+
+@dataclass
+class ProjectConfig:
+    """Holds all user-selected options for a new FastAPI project."""
+
+    project_name: str
+    db: Database = Database.postgresql
+    orm: ORM = ORM.sqlalchemy
+    auth: AuthType = AuthType.jwt
+    broker: Broker = Broker.none
+    cache: Cache = Cache.none
+    stack: Stack = Stack.standard
+    ci: CIProvider = CIProvider.github
+    log_lib: LogLibrary = LogLibrary.loguru
+    storage: Storage = Storage.none
+    migration: MigrationTool = MigrationTool.none
+    ai: AIProvider = AIProvider.none
+    include_docker: bool = True
+    include_tests: bool = True
+    include_makefile: bool = True
+    dry_run: bool = False
+    force: bool = False
+    # Derived fields (set post-init)
+    package_name: str = field(default="", init=False)
+    slug: str = field(default="", init=False)
+
+    def __post_init__(self) -> None:
+        self.slug = self.project_name.lower().replace("-", "_").replace(" ", "_")
+        self.package_name = self.slug
+
+    # ── Convenience predicates ─────────────────────────────────────────────
+
+    @property
+    def has_relational_db(self) -> bool:
+        return self.db in (Database.postgresql, Database.mysql, Database.sqlite)
+
+    @property
+    def has_mongo(self) -> bool:
+        return self.db == Database.mongodb
+
+    @property
+    def has_auth(self) -> bool:
+        return self.auth != AuthType.none
+
+    @property
+    def has_broker(self) -> bool:
+        return self.broker != Broker.none
+
+    @property
+    def has_cache(self) -> bool:
+        return self.cache != Cache.none
+
+    @property
+    def has_docker(self) -> bool:
+        return self.include_docker and self.stack != Stack.minimal
+
+    @property
+    def has_infra(self) -> bool:
+        return self.stack == Stack.full
+
+    @property
+    def has_ci(self) -> bool:
+        return self.ci != CIProvider.none
+
+    @property
+    def has_storage(self) -> bool:
+        return self.storage != Storage.none
+
+    @property
+    def has_s3(self) -> bool:
+        return self.storage == Storage.s3
+
+    @property
+    def has_migration(self) -> bool:
+        return self.migration != MigrationTool.none
+
+    @property
+    def has_alembic(self) -> bool:
+        return self.migration == MigrationTool.alembic
+
+    @property
+    def has_ai(self) -> bool:
+        return self.ai != AIProvider.none
+
+    # ── Template context ───────────────────────────────────────────────────
+
+    def to_context(self) -> dict:
+        """Return a Jinja2-ready template context dict."""
+        return {
+            "project_name": self.project_name,
+            "package_name": self.package_name,
+            "slug": self.slug,
+            "db": self.db.value,
+            "orm": self.orm.value,
+            "auth": self.auth.value,
+            "broker": self.broker.value,
+            "cache": self.cache.value,
+            "stack": self.stack.value,
+            "ci": self.ci.value,
+            "log_lib": self.log_lib.value,
+            "storage": self.storage.value,
+            "migration": self.migration.value,
+            "ai": self.ai.value,
+            # Booleans for easy Jinja2 conditionals
+            "has_relational_db": self.has_relational_db,
+            "has_mongo": self.has_mongo,
+            "has_auth": self.has_auth,
+            "has_broker": self.has_broker,
+            "has_cache": self.has_cache,
+            "has_docker": self.has_docker,
+            "has_infra": self.has_infra,
+            "has_ci": self.has_ci,
+            "has_storage": self.has_storage,
+            "has_s3": self.has_s3,
+            "has_migration": self.has_migration,
+            "has_alembic": self.has_alembic,
+            "has_ai": self.has_ai,
+            "include_tests": self.include_tests,
+            "include_makefile": self.include_makefile,
+        }
+
+    def summary_lines(self) -> list[tuple[str, str]]:
+        """Return key-value pairs for display in the rich summary panel."""
+        rows = [
+            ("Project", self.project_name),
+            ("Package", self.package_name),
+            ("Database", self.db.value),
+            ("ORM", self.orm.value),
+            ("Migrations", self.migration.value),
+            ("Auth", self.auth.value),
+            ("Broker", self.broker.value),
+            ("Cache", self.cache.value),
+            ("Storage", self.storage.value),
+            ("AI", self.ai.value),
+            ("Stack", self.stack.value),
+            ("CI/CD", self.ci.value),
+            ("Logging", self.log_lib.value),
+            ("Docker", "yes" if self.has_docker else "no"),
+            ("Tests", "yes" if self.include_tests else "no"),
+            ("Dry-run", "yes" if self.dry_run else "no"),
+        ]
+        return rows

fastapi_spawn/constants.py

@@ -0,0 +1,133 @@
+"""Constants and enums for fastapi-spawn."""
+
+from enum import Enum
+
+
+class Database(str, Enum):
+    postgresql = "postgresql"
+    mysql = "mysql"
+    mongodb = "mongodb"
+    sqlite = "sqlite"
+    none = "none"
+
+
+class ORM(str, Enum):
+    sqlalchemy = "sqlalchemy"
+    tortoise = "tortoise"
+    beanie = "beanie"
+    none = "none"
+
+
+class AuthType(str, Enum):
+    jwt = "jwt"
+    oauth2 = "oauth2"
+    api_key = "api-key"
+    none = "none"
+
+
+class Broker(str, Enum):
+    redis = "redis"
+    rabbitmq = "rabbitmq"
+    kafka = "kafka"
+    none = "none"
+
+
+class Cache(str, Enum):
+    redis = "redis"
+    memcached = "memcached"
+    none = "none"
+
+
+class Stack(str, Enum):
+    minimal = "minimal"
+    standard = "standard"
+    full = "full"
+
+
+class CIProvider(str, Enum):
+    github = "github"
+    gitlab = "gitlab"
+    both = "both"
+    none = "none"
+
+
+class LogLibrary(str, Enum):
+    loguru = "loguru"
+    structlog = "structlog"
+    standard = "standard"
+
+
+class Storage(str, Enum):
+    s3 = "s3"
+    local = "local"
+    none = "none"
+
+
+class MigrationTool(str, Enum):
+    alembic = "alembic"   # SQLAlchemy / relational DBs
+    aerich = "aerich"     # Tortoise ORM
+    none = "none"
+
+
+class AIProvider(str, Enum):
+    openai = "openai"
+    anthropic = "anthropic"
+    none = "none"
+
+
+# ORM ↔ Database compatibility matrix
+ORM_DB_COMPAT: dict[str, list[str]] = {
+    ORM.sqlalchemy: [Database.postgresql, Database.mysql, Database.sqlite],
+    ORM.tortoise: [Database.postgresql, Database.mysql, Database.sqlite],
+    ORM.beanie: [Database.mongodb],
+    ORM.none: [Database.postgresql, Database.mysql, Database.mongodb, Database.sqlite, Database.none],
+}
+
+# Migration tool ↔ ORM compatibility
+MIGRATION_ORM_COMPAT: dict[str, list[str]] = {
+    MigrationTool.alembic: [ORM.sqlalchemy],
+    MigrationTool.aerich: [ORM.tortoise],
+    MigrationTool.none: list(ORM),
+}
+
+# Human-readable labels
+DB_LABELS = {
+    Database.postgresql: "PostgreSQL",
+    Database.mysql: "MySQL",
+    Database.mongodb: "MongoDB",
+    Database.sqlite: "SQLite",
+    Database.none: "No database",
+}
+
+AUTH_LABELS = {
+    AuthType.jwt: "JWT (JSON Web Tokens)",
+    AuthType.oauth2: "OAuth2 (Password flow)",
+    AuthType.api_key: "API Key",
+    AuthType.none: "No authentication",
+}
+
+BROKER_LABELS = {
+    Broker.redis: "Redis (via Celery)",
+    Broker.rabbitmq: "RabbitMQ (via Celery)",
+    Broker.kafka: "Kafka (via aiokafka)",
+    Broker.none: "No message broker",
+}
+
+STORAGE_LABELS = {
+    Storage.s3: "AWS S3 (via boto3)",
+    Storage.local: "Local filesystem",
+    Storage.none: "No file storage",
+}
+
+AI_LABELS = {
+    AIProvider.openai: "OpenAI (GPT-4o, GPT-4, embeddings)",
+    AIProvider.anthropic: "Anthropic (Claude 3.x)",
+    AIProvider.none: "No AI integration",
+}
+
+STACK_DESCRIPTIONS = {
+    Stack.minimal: "Core app only — no Docker, no infra",
+    Stack.standard: "App + Docker + GitHub CI",
+    Stack.full: "App + Docker + CI + Helm + Terraform",
+}
+