docs: update AI_RULES for all backend frameworks

- Enhance AI_RULES.md for Django, FastAPI, Flask, and Node.js templates
- Add database integration guidelines for each framework
- Include environment variable management best practices
- Update development workflow recommendations

Author: SFARPak

scaffold-backend/django/AI_RULES.md

@@ -1,16 +1,19 @@
 # Tech Stack
+
 - You are building a Django backend application.
 - Use Python 3.x.
 - Follow Django best practices and conventions.
 - Always put source code in the appropriate Django app folders.
 
 ## File Operations
+
 - Use `<write_to_file>` tags to create new files with their complete content
 - Use `<search_replace>` tags to modify existing files
 - Use `<run_terminal_cmd>` tags to execute Django management commands (migrations, startapp, etc.)
 - Always provide complete file content, not partial updates
 
 ## Project Structure
+
 - `config/`: Main Django project directory containing settings
 - `apps/`: Django applications directory
 - `apps/core/`: Core functionality and models
@@ -19,6 +22,7 @@
 - `requirements.txt`: Python dependencies
 
 ## Development Guidelines
+
 - Create Django apps for different features using `python manage.py startapp <app_name>`
 - Use Django's ORM for database operations
 - Implement proper URL routing in urls.py files
@@ -27,21 +31,24 @@
 - Use class-based views for complex logic
 
 ## Database
+
 - Default database is SQLite (db.sqlite3)
 - Use migrations for database schema changes: `python manage.py makemigrations` and `python manage.py migrate`
 - Define models in models.py files within each app
 
 ## API Development
+
 - Use Django REST Framework for API endpoints
 - Implement serializers for data validation and transformation
 - Use ViewSets for CRUD operations
 - Implement proper authentication and permissions
 - Add comprehensive API documentation
 
 ## Best Practices
+
 - Use class-based views for complex logic
 - Implement proper error handling and logging
 - Use Django's forms for data validation
 - Implement proper security measures (CSRF protection, authentication, authorization)
 - Write comprehensive tests in tests.py files
-- Use Django's caching framework for performance optimization
+- Use Django's caching framework for performance optimization

scaffold-backend/fastapi/AI_RULES.md

@@ -1,16 +1,19 @@
 # Tech Stack
+
 - You are building a FastAPI backend application.
 - Use Python 3.8+.
 - Follow FastAPI best practices and async/await patterns.
 - Always put source code in appropriate modules and packages.
 
 ## File Operations
+
 - Use `<write_to_file>` tags to create new files with their complete content
 - Use `<search_replace>` tags to modify existing files
 - Use `<run_terminal_cmd>` tags to execute FastAPI development commands
 - Always provide complete file content, not partial updates
 
 ## Project Structure
+
 - `main.py`: Main FastAPI application entry point
 - `requirements.txt`: Python dependencies
 - `app/`: Main application package
@@ -19,6 +22,7 @@
 - `app/models/`: Database models (when using ORM)
 
 ## Development Guidelines
+
 - Use Pydantic models for request/response validation
 - Implement proper async/await patterns for I/O operations
 - Use dependency injection with FastAPI's Depends()
@@ -28,6 +32,7 @@
 - Use SQLAlchemy or similar ORM for database operations
 
 ## API Design
+
 - Use meaningful HTTP status codes
 - Implement proper request/response models
 - Add comprehensive API documentation with docstrings
@@ -37,18 +42,20 @@
 - Add proper error responses with appropriate status codes
 
 ## Database Integration
+
 - Consider using SQLAlchemy with Alembic for migrations
 - Use async database drivers for better performance
 - Implement proper connection pooling
 - Use Pydantic models for data validation
 - Implement database sessions and transactions properly
 
 ## Best Practices
+
 - Use type hints throughout the codebase
 - Write comprehensive tests using pytest
 - Implement proper logging with Python's logging module
 - Use environment variables for configuration
 - Implement CORS middleware for frontend integration
 - Use background tasks for long-running operations
 - Implement rate limiting and security measures
-- Add proper authentication and authorization
+- Add proper authentication and authorization

scaffold-backend/flask/AI_RULES.md

@@ -1,16 +1,19 @@
 # Tech Stack
+
 - You are building a Flask backend application.
 - Use Python 3.x.
 - Follow Flask best practices and patterns.
 - Always put source code in appropriate modules and packages.
 
 ## File Operations
+
 - Use `<write_to_file>` tags to create new files with their complete content
 - Use `<search_replace>` tags to modify existing files
 - Use `<run_terminal_cmd>` tags to execute Flask development commands
 - Always provide complete file content, not partial updates
 
 ## Project Structure
+
 - `run.py`: Main Flask application entry point
 - `requirements.txt`: Python dependencies
 - `app/`: Main application package
@@ -19,13 +22,15 @@
 - `migrations/`: Database migration files (Flask-Migrate)
 
 ## Development Guidelines
+
 - Use Flask blueprints for larger applications to organize routes
 - Implement proper error handling with Flask's error handlers
 - Use Flask-WTF for form handling and validation
 - Implement proper JSON responses for API endpoints
 - Use Flask-SQLAlchemy or similar ORM for database operations
 
 ## API Design
+
 - Use meaningful HTTP status codes
 - Implement proper request/response handling
 - Add comprehensive API documentation
@@ -34,16 +39,18 @@
 - Use consistent JSON response formats
 
 ## Database Integration
+
 - Use SQLAlchemy with Flask-SQLAlchemy for ORM
 - Use Flask-Migrate for database migrations
 - Implement proper database connection handling
 - Use database sessions and transactions properly
 
 ## Best Practices
+
 - Use environment variables for configuration (consider python-dotenv)
 - Implement proper logging with Flask's logger
 - Write comprehensive tests using pytest or Flask's testing client
 - Use Flask's before_request and after_request decorators for middleware-like functionality
 - Implement CORS handling for frontend integration
 - Use Flask's session management for user sessions
-- Implement security measures (input validation, XSS protection, CSRF protection)
+- Implement security measures (input validation, XSS protection, CSRF protection)

scaffold-backend/nodejs/AI_RULES.md

@@ -1,16 +1,19 @@
 # Tech Stack
+
 - You are building a Node.js backend application.
 - Use modern JavaScript (ES6+) or TypeScript.
 - Follow Node.js best practices and Express.js patterns.
 - Always put source code in appropriate modules and directories.
 
 ## File Operations
+
 - Use `<write_to_file>` tags to create new files with their complete content
 - Use `<search_replace>` tags to modify existing files
 - Use `<run_terminal_cmd>` tags to execute Node.js development commands
 - Always provide complete file content, not partial updates
 
 ## Project Structure
+
 - `server.js`: Main Express application entry point
 - `package.json`: Node.js dependencies and scripts
 - Consider creating separate directories for larger applications:
@@ -23,6 +26,7 @@
   - `tests/`: Test files
 
 ## Development Guidelines
+
 - Use Express.js for routing and middleware
 - Implement proper error handling with middleware
 - Use environment variables for configuration (consider dotenv package)
@@ -31,6 +35,7 @@
 - Implement authentication and authorization (JWT, Passport.js, etc.)
 
 ## API Design
+
 - Follow REST API conventions
 - Use consistent JSON response formats
 - Implement proper error responses with appropriate status codes
@@ -39,18 +44,20 @@
 - Use middleware for authentication and authorization
 
 ## Database Integration
+
 - Consider using MongoDB with Mongoose
 - Or use SQL databases with Sequelize or TypeORM
 - Implement proper database connection handling
 - Use migrations for database schema changes
 - Implement data validation at the model level
 
 ## Best Practices
+
 - Use async/await or Promises for asynchronous operations
 - Implement proper error handling and logging
 - Write comprehensive tests using Jest or Mocha
 - Use ESLint for code linting
 - Implement security best practices (input validation, XSS protection, etc.)
 - Use environment-specific configurations
 - Implement rate limiting and other security measures
-- Use clustering or PM2 for production deployment
+- Use clustering or PM2 for production deployment