@msn-control/liftoff 0.1.1

package/dist/templates.js

@@ -0,0 +1,1148 @@
+const pyModule = (value) => value.replace(/-/g, '_');
+const titleCase = (value) => value.replace(/(^|[-_\s])([a-z])/g, (_match, prefix, letter) => `${prefix ? ' ' : ''}${letter.toUpperCase()}`).trim();
+export function buildArtifacts(plan) {
+    const artifacts = [];
+    const add = (logicalName, category, pathParts, content) => {
+        artifacts.push({ logicalName, category, pathParts, content: ensureTrailingNewline(content) });
+    };
+    addBaseArtifacts(add, plan);
+    addBackendArtifacts(add, plan);
+    addDatabaseArtifacts(add, plan);
+    addPatternArtifacts(add, plan);
+    addEnvironmentArtifacts(add, plan);
+    addDockerArtifacts(add, plan);
+    addInfrastructureArtifacts(add, plan);
+    addGovernanceArtifacts(add, plan);
+    if (plan.includeFrontend) {
+        addFrontendArtifacts(add, plan);
+    }
+    const manifest = buildManifest(plan, artifacts);
+    artifacts.push({
+        logicalName: 'manifest',
+        category: 'manifest',
+        pathParts: ['liftoff.manifest.json'],
+        content: `${JSON.stringify(manifest, null, 2)}\n`
+    });
+    return artifacts;
+}
+export function buildManifest(plan, artifacts) {
+    return {
+        artifactVersion: 1,
+        generatedBy: 'Mission Control Liftoff',
+        project: {
+            name: plan.projectName,
+            pattern: plan.pattern.id,
+            cloud: plan.provider.id,
+            region: plan.region.slug,
+            frontend: plan.includeFrontend,
+            specWorkflow: plan.specWorkflow.id,
+            environments: plan.environments.map((environment) => environment.id)
+        },
+        artifacts: artifacts.map((artifact) => ({
+            logicalName: artifact.logicalName,
+            category: artifact.category,
+            pathParts: artifact.pathParts
+        }))
+    };
+}
+function addBaseArtifacts(add, plan) {
+    add('root-readme', 'documentation', ['README.md'], renderRootReadme(plan));
+    add('root-gitignore', 'project', ['.gitignore'], renderGeneratedGitignore());
+    add('liftoff-config', 'project', ['liftoff.config.json'], JSON.stringify({
+        projectName: plan.projectName,
+        pattern: plan.pattern.id,
+        cloud: plan.provider.id,
+        region: plan.region.slug,
+        includeFrontend: plan.includeFrontend,
+        environments: plan.environments.map((environment) => environment.id),
+        specWorkflow: plan.specWorkflow.id
+    }, null, 2));
+    add('env-example', 'configuration', ['.env.example'], renderEnvExample(plan));
+    add('backend-dockerfile', 'runtime', ['Dockerfile'], renderBackendDockerfile());
+}
+function addBackendArtifacts(add, plan) {
+    const routeModule = pyModule(plan.pattern.id);
+    add('backend-pyproject', 'backend', ['backend', 'pyproject.toml'], renderBackendPyproject(plan));
+    add('backend-package', 'backend', ['backend', '__init__.py'], '');
+    add('backend-api-package', 'backend', ['backend', 'apis', '__init__.py'], '');
+    add('backend-main', 'backend', ['backend', 'apis', 'main.py'], renderFastApiMain(plan, routeModule));
+    add('backend-health-routes', 'backend', ['backend', 'apis', 'routes', 'health.py'], renderHealthRoutes());
+    add('backend-pattern-routes', 'backend', ['backend', 'apis', 'routes', `${routeModule}.py`], renderPatternRoutes(plan));
+    add('backend-routes-package', 'backend', ['backend', 'apis', 'routes', '__init__.py'], '');
+    add('backend-auth-dependency', 'backend', ['backend', 'apis', 'dependencies', 'auth.py'], renderAuthDependency());
+    add('backend-config-package', 'backend', ['backend', 'config', '__init__.py'], '');
+    add('backend-settings', 'backend', ['backend', 'config', 'settings.py'], renderSettings(plan));
+    add('backend-orchestration-package', 'backend', ['backend', 'orchestration', '__init__.py'], '');
+    add('backend-model-config', 'backend', ['backend', 'orchestration', 'model_config.py'], renderModelConfig(plan));
+    add('backend-messaging-tool', 'backend', ['backend', 'orchestration', 'tools', 'messaging.py'], renderMessagingBoundary());
+    add('backend-tools-package', 'backend', ['backend', 'orchestration', 'tools', '__init__.py'], '');
+    add('backend-observability', 'backend', ['backend', 'observability', 'tracing.py'], renderTracing());
+    add('backend-observability-package', 'backend', ['backend', 'observability', '__init__.py'], '');
+    add('backend-test-health', 'backend-test', ['backend', 'tests', 'test_health.py'], renderBackendHealthTest());
+}
+function addDatabaseArtifacts(add, plan) {
+    add('database-alembic-ini', 'database', ['database', 'alembic.ini'], renderAlembicIni());
+    add('database-alembic-env', 'database', ['database', 'migrations', 'env.py'], renderAlembicEnv());
+    add('database-initial-migration', 'database', ['database', 'migrations', 'versions', '0001_initial.py'], renderInitialMigration(plan));
+    add('database-schema', 'database', ['database', 'models', 'schema.sql'], renderDatabaseSchema(plan));
+}
+function addPatternArtifacts(add, plan) {
+    const routeModule = pyModule(plan.pattern.id);
+    add('pattern-agent', 'pattern', ['backend', 'orchestration', 'agents', `${routeModule}_agent.py`], renderPatternAgent(plan));
+    add('pattern-prompt', 'pattern', ['backend', 'orchestration', 'prompts', `${plan.pattern.id}.md`], renderPromptTemplate(plan));
+    add('pattern-agent-package', 'pattern', ['backend', 'orchestration', 'agents', '__init__.py'], '');
+    add('pattern-prompt-readme', 'pattern', ['backend', 'orchestration', 'prompts', 'README.md'], renderPromptReadme());
+    if (plan.pattern.id === 'rag') {
+        add('rag-vector-store', 'pattern', ['backend', 'orchestration', 'retrieval', 'vector_store.py'], renderVectorStore());
+        add('rag-retrieval-package', 'pattern', ['backend', 'orchestration', 'retrieval', '__init__.py'], '');
+    }
+    if (plan.pattern.worker) {
+        add('pattern-worker', 'pattern', ['backend', 'workers', `${routeModule}_worker.py`], renderPatternWorker(plan));
+        add('backend-workers-package', 'pattern', ['backend', 'workers', '__init__.py'], '');
+    }
+    if (plan.pattern.id === 'fine-tuned') {
+        add('fine-tuned-eval-dataset', 'pattern', ['backend', 'evaluation', 'datasets', 'sample.jsonl'], '{"input":"Example request","expected":"Expected response placeholder"}');
+    }
+}
+function addEnvironmentArtifacts(add, plan) {
+    for (const environment of plan.environments) {
+        add(`environment-${environment.id}-backend`, 'environment', ['environments', environment.id, 'backend.env'], renderBackendEnv(plan, environment.id));
+    }
+}
+function addDockerArtifacts(add, plan) {
+    add('docker-compose', 'local-development', ['docker-compose.yml'], renderDockerCompose(plan));
+}
+function addInfrastructureArtifacts(add, plan) {
+    const base = ['infrastructure', 'opentofu', 'azure'];
+    add('opentofu-versions', 'infrastructure', [...base, 'versions.tf'], renderTofuVersions());
+    add('opentofu-providers', 'infrastructure', [...base, 'providers.tf'], renderTofuProviders());
+    add('opentofu-variables', 'infrastructure', [...base, 'variables.tf'], renderTofuVariables(plan));
+    add('opentofu-main', 'infrastructure', [...base, 'main.tf'], renderTofuMain(plan));
+    add('opentofu-outputs', 'infrastructure', [...base, 'outputs.tf'], renderTofuOutputs(plan));
+    add('opentofu-local-state', 'infrastructure', [...base, 'backend.local.tf'], renderTofuLocalState());
+    add('opentofu-remote-state-example', 'infrastructure', [...base, 'backend.remote.example.tf'], renderTofuRemoteStateExample());
+    add('opentofu-readme', 'infrastructure', [...base, 'README.md'], renderTofuReadme(plan));
+    for (const environment of plan.environments) {
+        add(`opentofu-${environment.id}-tfvars`, 'infrastructure', [...base, 'environments', `${environment.id}.tfvars`], renderTofuTfvars(plan, environment.id));
+    }
+}
+function addGovernanceArtifacts(add, plan) {
+    if (plan.specWorkflow.id === 'openspec') {
+        const changeName = `bootstrap-${plan.safeProjectName}`;
+        add('openspec-config', 'governance', ['openspec', 'config.yaml'], renderOpenSpecConfig(plan));
+        add('openspec-seed-change-metadata', 'governance', ['openspec', 'changes', changeName, '.openspec.yaml'], 'schema: spec-driven');
+        add('openspec-seed-proposal', 'governance', ['openspec', 'changes', changeName, 'proposal.md'], renderSeedProposal(plan));
+        add('openspec-seed-design', 'governance', ['openspec', 'changes', changeName, 'design.md'], renderSeedDesign(plan));
+        add('openspec-seed-tasks', 'governance', ['openspec', 'changes', changeName, 'tasks.md'], renderSeedTasks());
+        add('openspec-spec-placeholder', 'governance', ['openspec', 'specs', '.gitkeep'], '');
+    }
+    else {
+        add('spec-kit-constitution', 'governance', ['.specify', 'memory', 'constitution.md'], renderSpecKitConstitution(plan));
+        add('spec-kit-spec-template', 'governance', ['.specify', 'templates', 'spec-template.md'], renderSpecKitSpecTemplate());
+        add('spec-kit-plan-template', 'governance', ['.specify', 'templates', 'plan-template.md'], renderSpecKitPlanTemplate());
+        add('specs-placeholder', 'governance', ['specs', '.gitkeep'], '');
+    }
+}
+function addFrontendArtifacts(add, plan) {
+    add('frontend-package', 'frontend', ['frontend', 'package.json'], renderFrontendPackage(plan));
+    add('frontend-index', 'frontend', ['frontend', 'index.html'], renderFrontendIndex(plan));
+    add('frontend-main', 'frontend', ['frontend', 'src', 'main.ts'], renderFrontendMain());
+    add('frontend-app', 'frontend', ['frontend', 'src', 'App.vue'], renderFrontendApp(plan));
+    add('frontend-styles', 'frontend', ['frontend', 'src', 'styles.css'], renderFrontendStyles());
+    add('frontend-vite-config', 'frontend', ['frontend', 'vite.config.ts'], renderFrontendViteConfig());
+    add('frontend-tailwind-config', 'frontend', ['frontend', 'tailwind.config.ts'], renderFrontendTailwindConfig());
+    add('frontend-dockerfile', 'frontend', ['frontend', 'Dockerfile'], renderFrontendDockerfile());
+}
+function renderRootReadme(plan) {
+    return `# ${plan.projectName}
+
+Generated by Mission Control Liftoff.
+
+## Stack
+
+- Backend: FastAPI, PydanticAI, Pydantic settings, Scalar
+- Pattern: ${plan.pattern.label}
+- Cloud: ${plan.provider.label} (${plan.region.slug})
+- Infrastructure: OpenTofu
+- Database: PostgreSQL with Alembic migrations${plan.pattern.id === 'rag' ? ' and pgvector retrieval' : ''}
+- Cache and local messaging: Redis
+- Observability: Langfuse
+- Local development: Docker Compose
+${plan.includeFrontend ? '- Frontend: Vue 3 with Tailwind\n' : ''}
+## Local Development
+
+\`\`\`bash
+docker compose up --build
+docker compose --profile observability up --build
+\`\`\`
+
+The backend API is available on port 8000. Scalar is exposed at \`/scalar\`.
+
+## Infrastructure
+
+\`\`\`bash
+cd infrastructure/opentofu/azure
+tofu init
+tofu plan -var-file=environments/dev.tfvars
+tofu apply -var-file=environments/dev.tfvars
+\`\`\`
+
+## Spec-Driven Workflow
+
+Selected workflow: ${plan.specWorkflow.label}.
+`;
+}
+function renderGeneratedGitignore() {
+    return `.venv/
+__pycache__/
+.pytest_cache/
+node_modules/
+dist/
+.env
+*.tfstate
+*.tfstate.*
+.terraform/
+`;
+}
+function renderEnvExample(plan) {
+    return `APP_ENV=dev
+APP_NAME=${plan.safeProjectName}
+GENAI_PATTERN=${plan.pattern.id}
+CLOUD_PROVIDER=${plan.provider.id}
+AZURE_REGION=${plan.region.slug}
+DATABASE_URL=postgresql+asyncpg://postgres:postgres@postgres:5432/${plan.safeProjectName.replace(/-/g, '_')}
+REDIS_URL=redis://redis:6379/0
+MESSAGING_TRANSPORT=redis-streams
+BLOB_ENDPOINT=http://azurite:10000/devstoreaccount1
+LANGFUSE_HOST=http://langfuse:3000
+`;
+}
+function renderBackendDockerfile() {
+    return `FROM python:3.12-slim
+
+WORKDIR /app
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONPATH=/app
+
+COPY backend/pyproject.toml /app/backend/pyproject.toml
+RUN pip install --no-cache-dir /app/backend
+
+COPY backend /app/backend
+COPY database /app/database
+
+EXPOSE 8000
+CMD ["uvicorn", "backend.apis.main:app", "--host", "0.0.0.0", "--port", "8000"]
+`;
+}
+function renderBackendPyproject(plan) {
+    return `[project]
+name = "${plan.safeProjectName}-backend"
+version = "0.1.0"
+requires-python = ">=3.12"
+dependencies = [
+  "fastapi>=0.111",
+  "uvicorn[standard]>=0.30",
+  "pydantic>=2.7",
+  "pydantic-settings>=2.3",
+  "pydantic-ai>=0.0.13",
+  "scalar-fastapi>=1.0",
+  "sqlalchemy[asyncio]>=2.0",
+  "asyncpg>=0.29",
+  "alembic>=1.13",
+  "redis>=5.0",
+  "langfuse>=2.39",
+  "azure-servicebus>=7.12",
+  "azure-storage-blob>=12.20",
+  "azure-communication-email>=1.0"
+]
+
+[project.optional-dependencies]
+test = ["pytest>=8.2", "httpx>=0.27"]
+
+[build-system]
+requires = ["setuptools>=70"]
+build-backend = "setuptools.build_meta"
+
+[tool.pytest.ini_options]
+pythonpath = [".."]
+testpaths = ["tests"]
+`;
+}
+function renderFastApiMain(plan, routeModule) {
+    return `from fastapi import FastAPI
+
+try:
+    from scalar_fastapi import get_scalar_api_reference
+except ImportError:  # pragma: no cover - dependency is present in generated runtime
+    get_scalar_api_reference = None
+
+from backend.apis.routes import health, ${routeModule}
+from backend.config.settings import get_settings
+
+
+settings = get_settings()
+app = FastAPI(title=settings.app_name, version="0.1.0")
+
+app.include_router(health.router)
+app.include_router(${routeModule}.router)
+
+
+@app.get("/scalar", include_in_schema=False)
+def scalar_reference():
+    if get_scalar_api_reference is None:
+        return {"message": "Install scalar-fastapi to enable the Scalar developer portal."}
+    return get_scalar_api_reference(openapi_url=app.openapi_url, title=f"{app.title} API")
+`;
+}
+function renderHealthRoutes() {
+    return `from fastapi import APIRouter
+
+router = APIRouter(tags=["operations"])
+
+
+@router.get("/health")
+def health():
+    return {"status": "ok"}
+
+
+@router.get("/ready")
+def ready():
+    return {"status": "ready"}
+`;
+}
+function renderPatternRoutes(plan) {
+    const moduleName = pyModule(plan.pattern.id);
+    const agentName = `${moduleName}_agent`;
+    const prefix = plan.pattern.routePrefix;
+    if (plan.pattern.id === 'streaming') {
+        return `from fastapi import APIRouter
+from fastapi.responses import StreamingResponse
+
+from backend.orchestration.agents.${agentName} import stream_response
+
+router = APIRouter(prefix="${prefix}", tags=["${plan.pattern.id}"])
+
+
+@router.get("")
+def stream(prompt: str):
+    return StreamingResponse(stream_response(prompt), media_type="text/event-stream")
+`;
+    }
+    if (plan.pattern.id === 'rag') {
+        return `from fastapi import APIRouter
+from pydantic import BaseModel
+
+from backend.orchestration.agents.${agentName} import answer_question, enqueue_ingestion
+
+router = APIRouter(prefix="${prefix}", tags=["rag"])
+
+
+class QueryRequest(BaseModel):
+    question: str
+
+
+class IngestionRequest(BaseModel):
+    source_uri: str
+
+
+@router.post("/query")
+async def query(request: QueryRequest):
+    return await answer_question(request.question)
+
+
+@router.post("/ingest")
+async def ingest(request: IngestionRequest):
+    return await enqueue_ingestion(request.source_uri)
+`;
+    }
+    const bodyClass = `${titleCase(plan.pattern.id).replace(/\s/g, '')}Request`;
+    return `from fastapi import APIRouter
+from pydantic import BaseModel
+
+from backend.orchestration.agents.${agentName} import run_${moduleName}
+
+router = APIRouter(prefix="${prefix}", tags=["${plan.pattern.id}"])
+
+
+class ${bodyClass}(BaseModel):
+    input: str
+
+
+@router.post("/run")
+async def run(request: ${bodyClass}):
+    return await run_${moduleName}(request.input)
+`;
+}
+function renderAuthDependency() {
+    return `from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class CurrentUser:
+    subject: str = "local-developer"
+
+
+async def get_current_user() -> CurrentUser:
+    return CurrentUser()
+`;
+}
+function renderSettings(plan) {
+    return `from functools import lru_cache
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore")
+
+    app_name: str = "${plan.projectName}"
+    app_env: str = "dev"
+    genai_pattern: str = "${plan.pattern.id}"
+    cloud_provider: str = "${plan.provider.id}"
+    azure_region: str = "${plan.region.slug}"
+    database_url: str
+    redis_url: str
+    messaging_transport: str = "redis-streams"
+    blob_endpoint: str | None = None
+    langfuse_host: str | None = None
+
+
+@lru_cache
+def get_settings() -> Settings:
+    return Settings()
+`;
+}
+function renderModelConfig(plan) {
+    return `from pydantic import BaseModel, Field
+
+
+class ModelConfig(BaseModel):
+    provider: str = Field(default="azure-openai")
+    deployment_name: str = Field(default="gpt-4.1")
+    embedding_deployment_name: str = Field(default="text-embedding-3-large")
+    pattern: str = Field(default="${plan.pattern.id}")
+`;
+}
+function renderMessagingBoundary() {
+    return `from typing import Protocol
+
+
+class MessagePublisher(Protocol):
+    async def publish(self, topic: str, payload: dict) -> None:
+        ...
+
+
+class RedisStreamPublisher:
+    async def publish(self, topic: str, payload: dict) -> None:
+        # Implement with redis.asyncio in application code.
+        return None
+
+
+class AzureServiceBusPublisher:
+    async def publish(self, topic: str, payload: dict) -> None:
+        # Implement with azure-servicebus in cloud configuration.
+        return None
+
+
+def build_message_publisher(transport: str) -> MessagePublisher:
+    if transport == "azure-service-bus":
+        return AzureServiceBusPublisher()
+    return RedisStreamPublisher()
+`;
+}
+function renderTracing() {
+    return `from contextlib import asynccontextmanager
+
+
+@asynccontextmanager
+async def trace_llm_operation(name: str):
+    # Wire Langfuse callbacks here when model credentials are configured.
+    yield {"trace": name}
+`;
+}
+function renderBackendHealthTest() {
+    return `from fastapi.testclient import TestClient
+
+from backend.apis.main import app
+
+
+def test_health():
+    client = TestClient(app)
+    response = client.get("/health")
+    assert response.status_code == 200
+    assert response.json()["status"] == "ok"
+`;
+}
+function renderAlembicIni() {
+    return `[alembic]
+script_location = migrations
+sqlalchemy.url = driver://user:pass@localhost/dbname
+`;
+}
+function renderAlembicEnv() {
+    return `from alembic import context
+
+
+def run_migrations_online():
+    context.configure(url=context.get_x_argument(as_dictionary=True).get("database_url"))
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+run_migrations_online()
+`;
+}
+function renderInitialMigration(plan) {
+    const vectorExtension = plan.pattern.id === 'rag' ? '    op.execute("CREATE EXTENSION IF NOT EXISTS vector")\n' : '';
+    return `from alembic import op
+import sqlalchemy as sa
+
+revision = "0001_initial"
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+${vectorExtension}    op.create_table(
+        "events",
+        sa.Column("id", sa.Integer(), primary_key=True),
+        sa.Column("event_type", sa.String(length=120), nullable=False),
+        sa.Column("payload", sa.JSON(), nullable=False),
+        sa.Column("created_at", sa.DateTime(), server_default=sa.func.now(), nullable=False),
+    )
+
+
+def downgrade():
+    op.drop_table("events")
+`;
+}
+function renderDatabaseSchema(plan) {
+    return `CREATE TABLE IF NOT EXISTS events (
+  id SERIAL PRIMARY KEY,
+  event_type VARCHAR(120) NOT NULL,
+  payload JSONB NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+${plan.pattern.id === 'rag' ? '\nCREATE EXTENSION IF NOT EXISTS vector;\n' : ''}`;
+}
+function renderPatternAgent(plan) {
+    const moduleName = pyModule(plan.pattern.id);
+    if (plan.pattern.id === 'rag') {
+        return `from backend.orchestration.tools.messaging import build_message_publisher
+
+
+async def answer_question(question: str) -> dict:
+    return {
+        "answer": "Replace this placeholder with PydanticAI retrieval orchestration.",
+        "question": question,
+        "citations": [],
+    }
+
+
+async def enqueue_ingestion(source_uri: str) -> dict:
+    publisher = build_message_publisher("redis-streams")
+    await publisher.publish("rag.ingest", {"source_uri": source_uri})
+    return {"status": "queued", "source_uri": source_uri}
+`;
+    }
+    if (plan.pattern.id === 'streaming') {
+        return `async def stream_response(prompt: str):
+    yield f"data: Starting response for {prompt}\\n\\n"
+    yield "data: Replace this placeholder with PydanticAI streaming orchestration.\\n\\n"
+`;
+    }
+    return `async def run_${moduleName}(input_text: str) -> dict:
+    return {
+        "result": "Replace this placeholder with ${plan.pattern.label} PydanticAI orchestration.",
+        "input": input_text,
+    }
+`;
+}
+function renderPromptTemplate(plan) {
+    return `# ${plan.pattern.label} Prompt
+
+You are implementing a ${plan.pattern.label} generated by Mission Control Liftoff.
+
+Use PydanticAI orchestration and return outputs that match the API contract.
+`;
+}
+function renderPromptReadme() {
+    return `# Prompt Templates
+
+Store prompt templates here and reference them from the PydanticAI orchestration layer.
+`;
+}
+function renderVectorStore() {
+    return `from typing import Protocol
+
+
+class VectorStore(Protocol):
+    async def search(self, query: str, limit: int = 5) -> list[dict]:
+        ...
+
+
+class PgVectorStore:
+    async def search(self, query: str, limit: int = 5) -> list[dict]:
+        return []
+`;
+}
+function renderPatternWorker(plan) {
+    return `async def run_worker() -> None:
+    # Consume ${plan.pattern.label} jobs from the configured messaging boundary.
+    return None
+`;
+}
+function renderBackendEnv(plan, environment) {
+    const transport = environment === 'dev' ? 'redis-streams' : 'azure-service-bus';
+    return `APP_ENV=${environment}
+APP_NAME=${plan.safeProjectName}
+GENAI_PATTERN=${plan.pattern.id}
+CLOUD_PROVIDER=${plan.provider.id}
+AZURE_REGION=${plan.region.slug}
+DATABASE_URL=postgresql+asyncpg://postgres:postgres@postgres:5432/${plan.safeProjectName.replace(/-/g, '_')}
+REDIS_URL=redis://redis:6379/0
+MESSAGING_TRANSPORT=${transport}
+BLOB_ENDPOINT=
+LANGFUSE_HOST=
+`;
+}
+function renderDockerCompose(plan) {
+    const frontendService = plan.includeFrontend ? `
+  frontend:
+    build:
+      context: ./frontend
+    ports:
+      - "5173:80"
+    depends_on:
+      - backend
+` : '';
+    return `services:
+  backend:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    env_file:
+      - ./environments/dev/backend.env
+    ports:
+      - "8000:8000"
+    depends_on:
+      - postgres
+      - redis
+      - azurite
+      - mailpit
+${frontendService}
+  postgres:
+    image: pgvector/pgvector:pg16
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: ${plan.safeProjectName.replace(/-/g, '_')}
+    ports:
+      - "5432:5432"
+
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+
+  azurite:
+    image: mcr.microsoft.com/azure-storage/azurite
+    command: azurite --blobHost 0.0.0.0
+    ports:
+      - "10000:10000"
+
+  mailpit:
+    image: axllent/mailpit:latest
+    ports:
+      - "8025:8025"
+
+  langfuse:
+    image: langfuse/langfuse:2
+    profiles:
+      - observability
+    environment:
+      DATABASE_URL: postgresql://postgres:postgres@postgres:5432/${plan.safeProjectName.replace(/-/g, '_')}
+      NEXTAUTH_SECRET: local-development-placeholder
+      SALT: local-development-placeholder
+    ports:
+      - "3000:3000"
+`;
+}
+function renderTofuVersions() {
+    return `terraform {
+  required_version = ">= 1.6.0"
+  required_providers {
+    azurerm = {
+      source  = "hashicorp/azurerm"
+      version = "~> 3.110"
+    }
+  }
+}
+`;
+}
+function renderTofuProviders() {
+    return `provider "azurerm" {
+  features {}
+}
+`;
+}
+function renderTofuVariables(plan) {
+    return `variable "environment" {
+  type        = string
+  description = "Deployment environment name."
+}
+
+variable "location" {
+  type        = string
+  description = "Azure region slug."
+  default     = "${plan.region.slug}"
+}
+
+variable "resource_suffix" {
+  type        = string
+  description = "Globally unique suffix for Azure resource names."
+}
+
+variable "postgres_admin_password" {
+  type        = string
+  sensitive   = true
+  description = "PostgreSQL administrator password supplied at apply time."
+}
+
+variable "enable_private_networking" {
+  type        = bool
+  default     = false
+  description = "Enable production-oriented private-networking-ready settings."
+}
+`;
+}
+function renderTofuMain(plan) {
+    const frontendContainer = plan.includeFrontend ? `
+resource "azurerm_container_app" "frontend" {
+  name                         = "ca-${plan.safeProjectName}-frontend-\${var.environment}"
+  container_app_environment_id = azurerm_container_app_environment.main.id
+  resource_group_name          = azurerm_resource_group.main.name
+  revision_mode                = "Single"
+
+  template {
+    container {
+      name   = "frontend"
+      image  = "\${azurerm_container_registry.main.login_server}/${plan.safeProjectName}-frontend:latest"
+      cpu    = 0.25
+      memory = "0.5Gi"
+    }
+  }
+
+  ingress {
+    external_enabled = true
+    target_port      = 80
+    traffic_weight {
+      percentage      = 100
+      latest_revision = true
+    }
+  }
+}
+` : '';
+    return `locals {
+  name_prefix = "${plan.safeProjectName}-\${var.environment}"
+}
+
+resource "azurerm_resource_group" "main" {
+  name     = "rg-\${local.name_prefix}"
+  location = var.location
+}
+
+resource "azurerm_container_registry" "main" {
+  name                = "acr\${replace(var.resource_suffix, "-", "")}"
+  resource_group_name = azurerm_resource_group.main.name
+  location            = azurerm_resource_group.main.location
+  sku                 = "Basic"
+  admin_enabled       = false
+}
+
+resource "azurerm_user_assigned_identity" "app" {
+  name                = "id-\${local.name_prefix}"
+  resource_group_name = azurerm_resource_group.main.name
+  location            = azurerm_resource_group.main.location
+}
+
+resource "azurerm_container_app_environment" "main" {
+  name                = "cae-\${local.name_prefix}"
+  resource_group_name = azurerm_resource_group.main.name
+  location            = azurerm_resource_group.main.location
+}
+
+resource "azurerm_container_app" "backend" {
+  name                         = "ca-${plan.safeProjectName}-backend-\${var.environment}"
+  container_app_environment_id = azurerm_container_app_environment.main.id
+  resource_group_name          = azurerm_resource_group.main.name
+  revision_mode                = "Single"
+
+  identity {
+    type         = "UserAssigned"
+    identity_ids = [azurerm_user_assigned_identity.app.id]
+  }
+
+  template {
+    container {
+      name   = "backend"
+      image  = "\${azurerm_container_registry.main.login_server}/${plan.safeProjectName}-backend:latest"
+      cpu    = 0.5
+      memory = "1Gi"
+    }
+  }
+
+  ingress {
+    external_enabled = true
+    target_port      = 8000
+    traffic_weight {
+      percentage      = 100
+      latest_revision = true
+    }
+  }
+}
+${frontendContainer}
+resource "azurerm_postgresql_flexible_server" "main" {
+  name                   = "psql-\${local.name_prefix}-\${var.resource_suffix}"
+  resource_group_name    = azurerm_resource_group.main.name
+  location               = azurerm_resource_group.main.location
+  version                = "16"
+  administrator_login    = "liftoffadmin"
+  administrator_password = var.postgres_admin_password
+  storage_mb             = 32768
+  sku_name               = "B_Standard_B1ms"
+}
+
+resource "azurerm_redis_cache" "main" {
+  name                = "redis-\${local.name_prefix}-\${var.resource_suffix}"
+  location            = azurerm_resource_group.main.location
+  resource_group_name = azurerm_resource_group.main.name
+  capacity            = 0
+  family              = "C"
+  sku_name            = "Basic"
+}
+
+resource "azurerm_storage_account" "main" {
+  name                     = "st\${replace(var.resource_suffix, "-", "")}"
+  resource_group_name      = azurerm_resource_group.main.name
+  location                 = azurerm_resource_group.main.location
+  account_tier             = "Standard"
+  account_replication_type = "LRS"
+}
+
+resource "azurerm_storage_container" "documents" {
+  name                  = "documents"
+  storage_account_name  = azurerm_storage_account.main.name
+  container_access_type = "private"
+}
+
+resource "azurerm_servicebus_namespace" "main" {
+  name                = "sb-\${local.name_prefix}-\${var.resource_suffix}"
+  location            = azurerm_resource_group.main.location
+  resource_group_name = azurerm_resource_group.main.name
+  sku                 = "Standard"
+}
+
+resource "azurerm_servicebus_queue" "events" {
+  name         = "events"
+  namespace_id = azurerm_servicebus_namespace.main.id
+}
+
+resource "azurerm_communication_service" "main" {
+  name                = "acs-\${local.name_prefix}"
+  resource_group_name = azurerm_resource_group.main.name
+  data_location       = "United States"
+}
+
+resource "azurerm_key_vault" "main" {
+  name                = "kv-\${local.name_prefix}-\${var.resource_suffix}"
+  location            = azurerm_resource_group.main.location
+  resource_group_name = azurerm_resource_group.main.name
+  tenant_id           = data.azurerm_client_config.current.tenant_id
+  sku_name            = "standard"
+}
+
+data "azurerm_client_config" "current" {}
+`;
+}
+function renderTofuOutputs(plan) {
+    return `output "backend_url" {
+  value = azurerm_container_app.backend.ingress[0].fqdn
+}
+
+${plan.includeFrontend ? `output "frontend_url" {
+  value = azurerm_container_app.frontend.ingress[0].fqdn
+}
+` : ''}output "container_registry" {
+  value = azurerm_container_registry.main.login_server
+}
+`;
+}
+function renderTofuLocalState() {
+    return `# Local state is the V1 default for first-use simplicity.
+# Teams can replace this file with backend.remote.example.tf when adopting shared state.
+`;
+}
+function renderTofuRemoteStateExample() {
+    return `# Rename to backend.tf and configure values for shared state.
+# terraform {
+#   backend "azurerm" {
+#     resource_group_name  = "rg-opentofu-state"
+#     storage_account_name = "stliftoffstate"
+#     container_name       = "tfstate"
+#     key                  = "mission-control/liftoff.tfstate"
+#   }
+# }
+`;
+}
+function renderTofuReadme(plan) {
+    const env = plan.environments[0]?.id ?? 'dev';
+    return `# Azure OpenTofu
+
+Azure is the complete V1 provider for this Liftoff project.
+
+\`\`\`bash
+tofu init
+tofu plan -var-file=environments/${env}.tfvars
+tofu apply -var-file=environments/${env}.tfvars
+tofu output
+\`\`\`
+
+Local OpenTofu state is generated by default. Use \`backend.remote.example.tf\` as the starting point for team remote state.
+`;
+}
+function renderTofuTfvars(plan, environment) {
+    return `environment = "${environment}"
+location = "${plan.region.slug}"
+resource_suffix = "${plan.safeProjectName.replace(/-/g, '')}${environment}"
+enable_private_networking = ${environment === 'prod' ? 'true' : 'false'}
+`;
+}
+function renderOpenSpecConfig(plan) {
+    const frontendRule = plan.includeFrontend ? '\n    - Keep frontend code under frontend.' : '';
+    return `schema: spec-driven
+
+context: |
+  Project generated by Mission Control Liftoff.
+  GenAI pattern: ${plan.pattern.label}
+  Application framework: FastAPI + PydanticAI.
+  API developer portal: Scalar.
+  Infrastructure: OpenTofu.
+  Primary cloud: Azure (${plan.region.slug}).
+  Local development: Docker Compose.
+  Database: PostgreSQL with Alembic migrations.
+  Cache and local messaging: Redis.
+  Observability: Langfuse.
+  Environments: ${plan.environments.map((environment) => environment.id).join(', ')}.
+
+rules:
+  specs:
+    - Requirements must describe observable product behavior.
+    - Cloud behavior must identify environment differences for generated environments.
+  design:
+    - Use PydanticAI for orchestration logic.
+    - Use Pydantic settings models for runtime configuration.
+    - Use OpenTofu for infrastructure changes.${frontendRule}
+    - Keep backend API code under backend/apis.
+    - Keep database artifacts under database.
+  tasks:
+    - Include local Docker Compose verification.
+    - Include OpenTofu validation for generated infrastructure.
+`;
+}
+function renderSeedProposal(plan) {
+    return `## Why
+
+Bootstrap the generated ${plan.pattern.label} application baseline created by Mission Control Liftoff.
+
+## What Changes
+
+- Establish the approved backend, infrastructure, local development, and governance baseline.
+- Capture follow-up product requirements through spec-driven changes.
+
+## Capabilities
+
+### New Capabilities
+
+- \`${plan.pattern.id}-application-baseline\`: Generated application baseline for this Liftoff project.
+
+### Modified Capabilities
+
+- None.
+
+## Impact
+
+- Generated FastAPI/PydanticAI backend, OpenTofu infrastructure, Docker Compose local development, and governance files.
+`;
+}
+function renderSeedDesign(plan) {
+    return `## Context
+
+This project was generated with Liftoff using ${plan.pattern.label}, Azure, OpenTofu, and ${plan.specWorkflow.label}.
+
+## Goals / Non-Goals
+
+**Goals:**
+
+- Keep the generated baseline aligned to the approved Mission Control stack.
+
+**Non-Goals:**
+
+- Define domain-specific product behavior in the bootstrap change.
+
+## Decisions
+
+- Use FastAPI and PydanticAI for backend APIs and orchestration.
+- Use OpenTofu for Azure infrastructure.
+- Use Docker Compose for local development.
+
+## Risks / Trade-offs
+
+- The baseline contains placeholders that product-specific changes should replace.
+`;
+}
+function renderSeedTasks() {
+    return `## 1. Bootstrap Review
+
+- [ ] 1.1 Review generated baseline and replace placeholders with domain-specific requirements.
+- [ ] 1.2 Validate local Docker Compose startup.
+- [ ] 1.3 Validate OpenTofu plan for the first target environment.
+`;
+}
+function renderSpecKitConstitution(plan) {
+    return `# Mission Control Liftoff Constitution
+
+## Principle 1: Approved Application Stack
+Generated backend services MUST use FastAPI, PydanticAI, Pydantic configuration models, and Scalar for API documentation.
+
+## Principle 2: Standard Project Layout
+Backend APIs live under backend/apis. Database artifacts live under database.${plan.includeFrontend ? ' Frontend code lives under frontend.' : ''}
+
+## Principle 3: Infrastructure As Code
+Cloud infrastructure MUST be defined with OpenTofu. Azure is the supported V1 provider.
+
+## Principle 4: Local Development Parity
+Projects MUST include Docker Compose for local development with PostgreSQL, Redis, local blob storage, and local messaging behavior.
+
+## Principle 5: Observability And Operations
+LLM workflows MUST include Langfuse tracing hooks and environment-specific configuration for ${plan.environments.map((environment) => environment.id).join(', ')}.
+`;
+}
+function renderSpecKitSpecTemplate() {
+    return `# Feature Specification
+
+## User Scenarios
+
+## Requirements
+
+## Success Criteria
+`;
+}
+function renderSpecKitPlanTemplate() {
+    return `# Implementation Plan
+
+## Technical Context
+
+## Constitution Check
+
+## Tasks
+`;
+}
+function renderFrontendPackage(plan) {
+    return JSON.stringify({
+        name: `${plan.safeProjectName}-frontend`,
+        version: '0.1.0',
+        private: true,
+        type: 'module',
+        scripts: {
+            dev: 'vite',
+            build: 'vite build',
+            preview: 'vite preview'
+        },
+        dependencies: {
+            '@vitejs/plugin-vue': '^5.0.5',
+            vite: '^5.3.1',
+            vue: '^3.4.29',
+            tailwindcss: '^3.4.4',
+            autoprefixer: '^10.4.19',
+            postcss: '^8.4.38'
+        }
+    }, null, 2);
+}
+function renderFrontendIndex(plan) {
+    return `<div id="app"></div><script type="module" src="/src/main.ts"></script><title>${plan.projectName}</title>`;
+}
+function renderFrontendMain() {
+    return `import { createApp } from 'vue';
+import App from './App.vue';
+import './styles.css';
+
+createApp(App).mount('#app');
+`;
+}
+function renderFrontendApp(plan) {
+    return `<script setup lang="ts">
+const title = '${plan.projectName}';
+const starter = '${plan.frontendStarter}';
+const pattern = '${plan.pattern.label}';
+</script>
+
+<template>
+  <main class="min-h-screen bg-slate-50 text-slate-950">
+    <section class="mx-auto flex min-h-screen w-full max-w-5xl flex-col gap-6 px-6 py-10">
+      <header>
+        <p class="text-sm font-semibold uppercase tracking-wide text-emerald-700">Mission Control Liftoff</p>
+        <h1 class="mt-2 text-3xl font-bold">{{ title }}</h1>
+        <p class="mt-2 text-slate-600">{{ pattern }} starter</p>
+      </header>
+      <section class="rounded-lg border border-slate-200 bg-white p-6 shadow-sm">
+        <h2 class="text-xl font-semibold">{{ starter }}</h2>
+        <textarea class="mt-4 min-h-40 w-full rounded-md border border-slate-300 p-3" placeholder="Start with your application-specific input." />
+        <button class="mt-4 rounded-md bg-emerald-700 px-4 py-2 font-semibold text-white">Run</button>
+      </section>
+    </section>
+  </main>
+</template>
+`;
+}
+function renderFrontendStyles() {
+    return `@tailwind base;
+@tailwind components;
+@tailwind utilities;
+`;
+}
+function renderFrontendViteConfig() {
+    return `import { defineConfig } from 'vite';
+import vue from '@vitejs/plugin-vue';
+
+export default defineConfig({ plugins: [vue()] });
+`;
+}
+function renderFrontendTailwindConfig() {
+    return `import type { Config } from 'tailwindcss';
+
+export default {
+  content: ['./index.html', './src/**/*.{vue,ts}'],
+  theme: { extend: {} },
+  plugins: []
+} satisfies Config;
+`;
+}
+function renderFrontendDockerfile() {
+    return `FROM node:20-alpine AS build
+WORKDIR /app
+COPY package.json package-lock.json* ./
+RUN npm install
+COPY . .
+RUN npm run build
+
+FROM nginx:1.27-alpine
+COPY --from=build /app/dist /usr/share/nginx/html
+`;
+}
+function ensureTrailingNewline(content) {
+    return content.endsWith('\n') ? content : `${content}\n`;
+}
+//# sourceMappingURL=templates.js.map