Files

T

soroush.asadi 36fe158b43 Scaffold the Before-M1 repo skeleton

Stand up the modular-monolith skeleton per docs/V1_BUILD_PLAN.md: one .NET 10
solution with web + worker hosts sharing seven interface-bounded module projects,
PostgreSQL 17 + pgvector via EF Core 10, a React 19 + Vite SPA built into wwwroot,
and Docker Compose for one-command local dev. Skeleton only — no feature code.

Architecture
- One project per module (OrgBoard, Identity, Skills, Assembler, Governance,
  Memory, Integrations); each is its own assembly so non-public types (entities,
  DbContext) are invisible across modules at compile time.
- TeamUp.Bootstrap is the only library that references all modules; both hosts
  reference only Bootstrap. SharedKernel/Infrastructure never reference modules.
- IModule seam: Register(...) runs in both hosts; MapEndpoints(...) only in web.
- PlatformDbContext owns the pgvector extension + the seven module schemas
  (InitialPlatform migration); MigrationRunner applies it then any module context.
- One image, two roles selected by RUN_MODE at the Docker entrypoint.

Verified
- dotnet build green (nullable + warnings-as-errors).
- ArchitectureTests 8/8 — reflection-based boundary rules (no module -> module,
  -> Infrastructure, -> Bootstrap, or -> host references).
- IntegrationTests 10/10 — Testcontainers boots the host against real pgvector:
  migration applies, vector extension + 7 schemas exist, /health 200, every
  /api/<module>/ping 200, /openapi/v1.json served.
- client builds clean (Vite 6 — pinned for Node 22.3.0; Vite 8 needs Node >=22.12).

Packages and base images route through the Nexus mirror (mirror.soroushasadi.com),
reachable from Iran when nuget.org / Docker Hub / MCR are not. CI is intentionally
deferred to a later session.

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

2026-06-09 06:41:28 +03:30

4.1 KiB

Raw Blame History

TeamUp.AI

Build human + AI teams. A live org chart that does work: model the org, fill open role-seats with governed AI agents, run delivery on one board. A product of AliaSaaS.

Status: pre-M1 skeleton — the repo builds, tests green, and runs, but carries no feature code yet. See docs/V1_BUILD_PLAN.md for what M1–M6 add.

Stack

.NET 10 modular monolith (web + worker on one image) · PostgreSQL 17 + pgvector · EF Core 10 · React 19 + Vite SPA into wwwroot · Docker Compose for local dev. Full bill of materials in docs/V1_BUILD_PLAN.md.

Layout

src/Shared/TeamUp.SharedKernel     IModule seam, base Entity, IModuleDbContext
src/Shared/TeamUp.Infrastructure   PlatformDbContext (pgvector + schemas), MigrationRunner, wiring
src/Bootstrap/TeamUp.Bootstrap     the explicit module catalog (the only thing that knows all modules)
src/Modules/TeamUp.Modules.*       OrgBoard · Identity · Skills · Assembler · Governance · Memory · Integrations
src/Hosts/TeamUp.Web               ASP.NET Core API host (also serves the SPA)
src/Hosts/TeamUp.Worker            Generic Host worker (background jobs; M4+)
client/                            React/Vite SPA → builds into TeamUp.Web/wwwroot
tests/                             ArchitectureTests (boundary rules) · IntegrationTests (Testcontainers)
docker/                            Dockerfile (one image, two roles) · docker-compose.yml

Boundary rule: each module is its own assembly; everything but its IModule and public contracts is internal, so no module can touch another's persistence. TeamUp.ArchitectureTests backstops this — it fails the build if a module references another module / Infrastructure / a host.

Prerequisites

.NET SDK 10 · Node 22 · Docker. Packages and container images are pulled through a Nexus mirror — see Package & image sources below.

Quick start

# Backend: build, run the boundary + integration tests (integration needs Docker)
dotnet build TeamUp.slnx
dotnet test  TeamUp.slnx

# Local dev — two terminals, with the Vite dev server proxying /api to the .NET host
docker compose -f docker/docker-compose.yml up postgres -d   # Postgres 17 + pgvector
dotnet run --project src/Hosts/TeamUp.Web                     # http://localhost:5180  (applies migrations in Dev)
cd client && npm install && npm run dev                       # http://localhost:5173  (proxies /api, /health)

# Or run the whole thing in containers (web + worker + postgres, single image, RUN_MODE picks the role)
docker compose -f docker/docker-compose.yml up --build

GET /health is the DB health check; GET /api/<module>/ping proves each module seam; the OpenAPI document is at /openapi/v1.json (Development only).

EF Core migrations

dotnet ef migrations add <Name> \
  --project src/Shared/TeamUp.Infrastructure --startup-project src/Shared/TeamUp.Infrastructure \
  --context PlatformDbContext --output-dir Persistence/Migrations

The initial InitialPlatform migration enables the vector extension and creates one schema per module. Module-owned contexts (M1+) get their own migrations and apply after Platform via MigrationRunner.

Package & image sources

NuGet packages (nuget.config) and container base images (docker/Dockerfile, docker/docker-compose.yml) are pulled through the self-hosted Nexus mirror mirror.soroushasadi.com, which proxies nuget.org / Docker Hub / MCR and is reachable from Iran. To build against the public registries instead, point nuget.config at api.nuget.org and replace the mirror.soroushasadi.com/... image prefixes with docker.io/library (node) and mcr.microsoft.com (dotnet). Testcontainers picks up the mirror via TESTCONTAINERS_HUB_IMAGE_NAME_PREFIX=mirror.soroushasadi.com/.

CLAUDE.md — always-loaded project index
docs/CLAUDE.md — full architecture & domain model
docs/PRODUCT.md — complete product model
docs/V1_BUILD_PLAN.md — the V1 wedge (M1–M6) + bill of materials

4.1 KiB Raw Blame History Unescape Escape