---
name: project-architecture
description:
    BuildingAI monorepo project structure and architecture guide. Use when AI needs to understand
    project organization, locate files, understand package relationships, find where specific
    functionality is implemented, or navigate the codebase structure. Essential for any development
    task that requires understanding the project layout, import patterns, module organization, or
    cross-package dependencies.
---

# BuildingAI Project Architecture

Comprehensive guide to BuildingAI monorepo structure, packages, and development patterns.

## When to Use

Use this skill when you need to:

- Locate where specific functionality is implemented
- Understand package relationships and dependencies
- Find the correct import paths and patterns
- Navigate module organization and structure
- Understand development patterns and conventions
- Know what each package provides and how to use it

## Instructions

### Understanding the Monorepo Structure

The BuildingAI project is a pnpm workspace monorepo with the following structure:

```
buildingai/
├── packages/
│   ├── @buildingai/              # Shared packages
│   │   ├── ai-sdk/                 # AI SDK (legacy)
│   │   ├── ai-sdk-new/             # AI SDK (Vercel AI SDK 6.x)
│   │   ├── base/                   # BaseController, BaseService
│   │   ├── cache/                  # CacheService, RedisService
│   │   ├── config/                 # Configuration management
│   │   ├── constants/               # Shared constants
│   │   ├── db/                     # TypeORM, entities, migrations
│   │   ├── decorators/             # Custom decorators
│   │   ├── di/                     # Dependency injection utilities
│   │   ├── dict/                   # Dictionary/configuration management
│   │   ├── dto/                    # Shared DTOs
│   │   ├── errors/                 # HttpErrorFactory
│   │   ├── eslint-config/          # ESLint configuration
│   │   ├── extension-sdk/          # Extension development SDK
│   │   ├── logger/                 # Logging utilities
│   │   ├── pipe/                   # Validation pipes
│   │   ├── types/                  # TypeScript type definitions
│   │   ├── typescript-config/      # TypeScript configurations
│   │   ├── upgrade/                # Version upgrade scripts
│   │   ├── utils/                  # Utility functions, HTTP client
│   │   ├── web/                    # Frontend shared packages
│   │   │   ├── hooks/              # React hooks
│   │   │   ├── http/               # HTTP client
│   │   │   ├── services/           # Frontend services
│   │   │   ├── stores/             # State management (Pinia)
│   │   │   ├── types/              # TypeScript types
│   │   │   └── ui/                 # UI components
│   │   ├── di/                     # Dependency injection utilities
│   │   └── wechat-sdk/             # WeChat integration SDK
│   ├── api/                        # Main NestJS API application
│   ├── core/                       # Reusable business logic modules
│   ├── cli/                        # CLI tooling
│   └── client/                     # Desktop client (Tauri + React)
├── skills/                         # AI skills for development guidance
├── extensions/                     # Plugin extensions (runtime loaded)
├── public/                         # Static web assets
└── scripts/                        # Build and utility scripts
```

### Using Reference Files

For detailed information about each package, consult the corresponding reference file in
`references/`:

**@buildingai Packages:**

- `references/base.md` - BaseController, BaseService
- `references/cache.md` - CacheService, RedisService
- `references/config.md` - Configuration management
- `references/constants.md` - Shared constants
- `references/db.md` - Database layer (TypeORM, entities)
- `references/decorators.md` - Custom decorators
- `references/dict.md` - Dictionary management
- `references/dto.md` - Shared DTOs
- `references/errors.md` - Error handling
- `references/logger.md` - Logging utilities
- `references/utils.md` - Utility functions, HTTP client
- `references/ai-sdk.md` - AI SDK packages
- `references/web.md` - Frontend packages
- `references/extension-sdk.md` - Extension SDK
- `references/pipe.md` - Validation pipes
- `references/types.md` - TypeScript types
- `references/upgrade.md` - Version upgrade scripts
- `references/di.md` - Dependency injection utilities
- `references/wechat-sdk.md` - WeChat integration SDK

**Main Packages:**

- `references/api.md` - Main NestJS API application
- `references/core.md` - Reusable business logic
- `references/cli.md` - CLI tooling
- `references/client.md` - Desktop client

Load these reference files when you need detailed information about a specific package's exports,
usage patterns, or implementation details.

### Import Patterns

**Backend (API/Core) Import Order:**

1. `@buildingai/*` packages
2. `@nestjs/*` packages
3. `@common/*` (API only)
4. `@modules/*` (API only)
5. `@core/*` (API only)
6. Third-party packages
7. Relative paths

**Path Aliases (API):**

- `@common/*` → `src/common/*`
- `@modules/*` → `src/modules/*`
- `@core/*` → `src/core/*`
- `@assets/*` → `src/assets/*`

### Development Patterns

**Service Pattern:**

- Extend `BaseService<Entity>` from `@buildingai/base` for CRUD operations
- Use dependency injection with `@InjectRepository()` for repositories
- See `references/base.md` for available methods and features

**Controller Pattern:**

- Use `@ConsoleController(path, groupName)` for admin APIs (auto auth + permissions)
- Use `@WebController(path)` for frontend APIs (requires auth by default)
- Use `@Playground()` decorator to get current user
- See `references/decorators.md` and `references/api.md` for details

\*\*Module Structure: `src/modules/{module-name}/` with controllers, services, and DTOs

### Quick Navigation

When implementing features, reference the appropriate package:

- **Authentication**: `references/decorators.md` (`@Playground()`), `references/api.md` (guards)
- **Database**: `references/db.md` (entities), `references/base.md` (BaseService CRUD)
- **Error Handling**: `references/errors.md` (HttpErrorFactory)
- **Caching**: `references/cache.md` (CacheService, RedisService)
- **File Upload**: `references/core.md` (upload services)
- **AI Functionality**: `references/ai-sdk.md`, `references/api.md` (AI modules)
- **Frontend**: `references/web.md` (services, stores, UI components)

### Skills Integration

This skill works with other skills:

- **`postgresql-table-design`** - For database schema design
- **`frontend-design`** - For frontend UI development
- **`ai-sdk`** - For AI functionality implementation

When implementing features, reference the appropriate package reference file to understand what's
available and how to use it.
