#### Build & Development Commands
- **Backend (Python):**
  - `python -m venv venv`: Create a virtual environment.
  - `source venv/bin/activate`: Activate the virtual environment.
  - `pip install -r requirements.txt`: Install dependencies.
  - `python app.py`: Run the backend server.

- **Frontend (ReactJSX/Astro):**
  - `npm install`: Install dependencies.
  - `npm run dev`: Start the development server.
  - `npm run build`: Build the project for production.

#### Testing Guidelines
- **Unit Tests:**
  - Write unit tests for individual components and functions.
  - Use testing frameworks like `pytest` for Python and `Jest` for ReactJSX.

- **Integration Tests:**
  - Test the interaction between different components and services.
  - Ensure that the frontend and backend communicate correctly.

- **End-to-End Tests:**
  - Simulate user interactions and test the entire flow.
  - Use tools like `Cypress` for end-to-end testing.

#### Code Style & Guidelines
- **Python:**
  - Follow PEP 8 guidelines for code style.
  - Use linters like `flake8` to enforce code quality.

- **ReactJSX/Astro:**
  - Follow Airbnb JavaScript Style Guide.
  - Use `ESLint` to enforce code style and quality.

- **General:**
  - Write clean, modular, and reusable code.
  - Use meaningful variable and function names.
  - Comment code where necessary to explain complex logic.

#### Documentation Guidelines
- **Code Documentation:**
  - Use docstrings in Python to document functions and classes.
  - Use JSdoc in JavaScript/ReactJSX to document components and functions.

- **Project Documentation:**
  - Maintain a README file with project setup instructions.
  - Document API endpoints and their usage.
  - Provide examples and usage guidelines for custom components.

- **User Documentation:**
  - Create user guides and tutorials for using the AI assistant.
  - Provide troubleshooting tips and FAQs.

### Additional Python Deployment Rules

#### Environment Management
- **Virtual Environments:**
  - Always use virtual environments to manage dependencies. This ensures that the project's dependencies are isolated from other projects.
  - Use tools like `venv`, `virtualenv`, or `conda` to create virtual environments.

- **Dependency Management:**
  - Use `requirements.txt` or `Pipfile` to list project dependencies.
  - Pin dependency versions to ensure consistency across different environments.

#### Configuration Management
- **Environment Variables:**
  - Store configuration settings such as API keys, database URLs, and other sensitive information in environment variables.
  - Use libraries like `python-dotenv` to manage environment variables.

- **Configuration Files:**
  - Use configuration files (e.g., `config.py`, `settings.py`) to manage application settings.
  - Avoid hardcoding configuration values in the source code.

#### Logging and Monitoring
- **Logging:**
  - Implement logging to track application behavior and errors.
  - Use Python's built-in `logging` module or libraries like `loguru`.
  - Ensure logs are stored in a centralized location for easy access and analysis.

- **Monitoring:**
  - Integrate monitoring tools to track application performance and errors.
  - Use tools like Prometheus, Grafana, or Sentry for monitoring and alerting.

#### Scalability and Performance
- **Asynchronous Programming:**
  - Use asynchronous programming with `asyncio` or frameworks like FastAPI to handle concurrent tasks efficiently.

- **Caching:**
  - Implement caching to improve performance for frequently accessed data.
  - Use caching libraries like `cachetools` or integrate with caching services like Redis.

#### Security
- **Input Validation:**
  - Validate all user inputs to prevent security vulnerabilities like SQL injection and cross-site scripting (XSS).

- **Authentication and Authorization:**
  - Implement robust authentication and authorization mechanisms.
  - Use libraries like `Flask-Login` or `Django's authentication system`.

#### Deployment Automation
- **CI/CD Pipelines:**
  - Set up Continuous Integration/Continuous Deployment (CI/CD) pipelines to automate testing and deployment.
  - Use tools like GitHub Actions, GitLab CI, or Jenkins.

- **Containerization:**
  - Use Docker to containerize the application for consistent deployment across different environments.
  - Create a `Dockerfile` to define the application's environment and dependencies.

#### Documentation
- **Deployment Guides:**
  - Provide detailed deployment guides, including step-by-step instructions and troubleshooting tips.
  - Document environment setup, configuration, and common deployment issues.