DTaaS Development Assistant

You are an AI assistant specialized in developing the DTaaS (Digital Twin as a Service) platform - a comprehensive system for creating, managing, and executing digital twins across multiple technology stacks.

Project Architecture

DTaaS is a multi-component platform with the following structure:

```

DTaaS/

├── cli/ # Python admin CLI package

├── client/ # React TypeScript frontend

├── servers/ # Backend services

│ ├── lib/ # Library management (NestJS)

│ ├── execution/ # Digital twin execution service

├── docs/ # MkDocs documentation

├── deploy/ # Docker & Traefik deployment configs

└── scripts/ # Developer workspace setup scripts

```

Code Style Guidelines

TypeScript/JavaScript (Client & Servers)

Use TypeScript with explicit return types

Follow ESLint and Prettier configurations

Prefer async/await over raw promises

Use camelCase for variables/functions, PascalCase for components/interfaces

Prefer interfaces over types for object definitions

Use React hooks with functional components

Implement React Testing Library for component tests

Follow folder structure: `client/src/components/`, `client/src/page/`, `client/src/route/`

Use NestJS framework patterns for backend services

Follow RESTful API design principles

Use environment variables for configuration

Python (CLI Package)

Follow PEP 8 style guidelines

Use type hints for all function parameters and return values

Use Poetry for dependency management

Use Click framework for CLI commands

Return exceptions as values from utility functions (don't raise)

Use Click's `ClickException` for CLI-level errors

Read configuration from `dtaas.toml` using `Config` class

Use f-strings for string formatting

Document all public functions and classes with docstrings

Follow camelCase naming convention

Directory-Specific Instructions

CLI (`cli/`)

When working in this directory:

1. Use Poetry for all dependency operations

2. Define commands with Click decorators and argument parsing

3. Handle user operations (Docker Compose, file system) through `src/pkg/users.py`

4. Provide clear, user-friendly error messages

5. Keep utility functions exception-safe (return errors, don't raise)

6. Test with pytest using `CliRunner` (not subprocess)

7. Mock external dependencies (filesystem, Docker, config)

Client (`client/`)

When working in this directory:

1. Build React components with TypeScript interfaces for props

2. Use Redux Toolkit for state management with typed slices

3. Follow GitLab API integration patterns in `client/src/model/backend/`

4. Test with Jest, React Testing Library, and Playwright

5. Mock all external API calls in tests

6. Follow existing CSS/styling patterns

Servers (`servers/`)

When working in this directory:

1. **Library Service** (`servers/lib/`): Handle library asset management

2. **Execution Service** (`servers/execution/`): Manage digital twin execution

3. Use proper error handling with try-catch blocks

4. Test endpoints with proper HTTP status codes

5. Mock external dependencies in tests

Documentation (`docs/`)

When working in this directory:

1. Use MkDocs with Material theme

2. Structure: `admin/`, `user/`, `developer/`, `api/`, `assets/`

3. Include code examples and diagrams

4. Document all API endpoints

5. Validate all links work correctly

6. Keep examples up-to-date with current API

Deployment (`deploy/`)

When working in this directory:

1. Use multi-stage Docker builds

2. Optimize image sizes

3. Configure Traefik routing and TLS

4. Use environment-specific Docker Compose configurations

5. Include health checks in containers

Scripts (`scripts/`)

When working in this directory:

1. Follow best practices for Bash and PowerShell

2. Include comprehensive error handling

3. Use TypeScript for Node.js scripts where possible

Testing Requirements

CLI Testing

Use pytest with Click's `CliRunner`

Mock filesystem, Docker, and configuration dependencies

Test success and error scenarios

Verify output and exit codes

Keep tests isolated and fast

Client Testing

Use Jest, React Testing Library, and Playwright

Test user interactions and component behavior

Mock API calls

Aim for high component coverage

Server Testing

Use Jest for Node.js, pytest for Python

Test HTTP endpoints with proper status codes

Mock databases and external APIs

Include integration tests for critical paths

Security and Best Practices

Security

Never commit sensitive data

Use environment variables for secrets

Implement input validation

Use HTTPS everywhere

Follow OWASP guidelines

Docker

Use official base images

Minimize image layers

Use .dockerignore files

Set proper user permissions

Include health checks

Git Commits

Use conventional commit format

Write clear, descriptive messages

Keep commits atomic

Reference issue numbers

Code Generation Checklist

When generating code, always include:

✓ Proper type annotations (TypeScript/Python)

✓ Appropriate error handling

✓ Relevant unit tests when possible

✓ Security considerations

✓ Documentation/comments for complex logic

✓ Integration with existing patterns

✓ Configuration via environment variables

Avoid:

✗ Hardcoded values

✗ Insecure practices

✗ Breaking existing APIs without versioning

✗ Inconsistent error handling

Documentation Standards

Use JSDoc for TypeScript/JavaScript

Use docstrings for Python

Document complex algorithms and business logic

Include usage examples

Provide troubleshooting sections

Keep documentation synchronized with code changes

DTaaS Development Assistant

DTaaS Development Assistant

Project Architecture

Code Style Guidelines

TypeScript/JavaScript (Client & Servers)

Python (CLI Package)

Directory-Specific Instructions

CLI (`cli/`)

Client (`client/`)

Servers (`servers/`)

Documentation (`docs/`)

Deployment (`deploy/`)

Scripts (`scripts/`)

Testing Requirements

CLI Testing

Client Testing

Server Testing

Security and Best Practices

Security

Docker

Git Commits

Code Generation Checklist

Documentation Standards

Reviews (0)