Upload 178 files

.dockerignore

@@ -0,0 +1,76 @@
+# Git
+.git
+.gitignore
+
+# Python
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env
+pip-log.txt
+pip-delete-this-directory.txt
+.tox
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.log
+.git
+.mypy_cache
+.pytest_cache
+.hypothesis
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Project specific
+logs/
+*.log
+instance/
+flask_session/
+backups/
+ssl/
+
+# Documentation
+docs/
+*.md
+!README.md
+
+# Development files
+.env.example
+config/development.env
+config/testing.env
+docker-compose.dev.yml
+Dockerfile.dev
+
+# Test files
+tests/
+pytest.ini
+.coverage
+
+# Temporary files
+tmp/
+temp/
+*.tmp

.env.example

@@ -0,0 +1,44 @@
+# Groq API Configuration
+GROQ_API_KEY=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
+GROQ_MODEL=meta-llama/llama-4-scout-17b-16e-instruct
+
+# Database Configuration
+DATABASE_URL=postgresql://username:password@localhost:5432/chat_agent_db
+DB_HOST=localhost
+DB_PORT=5432
+DB_NAME=chat_agent_db
+DB_USER=admin
+DB_PASSWORD=admin
+
+# Redis Configuration
+REDIS_URL=redis://localhost:6379/0
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_DB=0
+REDIS_PASSWORD=Key@123
+
+# Flask Configuration
+FLASK_ENV=development
+FLASK_DEBUG=True
+SECRET_KEY=your_secret_key_here
+
+# Session Configuration
+SESSION_TYPE=redis
+SESSION_PERMANENT=False
+SESSION_USE_SIGNER=True
+SESSION_KEY_PREFIX=chat_agent:
+
+# Chat Agent Configuration
+DEFAULT_LANGUAGE=python
+MAX_CHAT_HISTORY=20
+CONTEXT_WINDOW_SIZE=10
+SESSION_TIMEOUT=3600
+
+# API Configuration
+MAX_TOKENS=2048
+TEMPERATURE=0.7
+STREAM_RESPONSES=True
+
+# Logging Configuration
+LOG_LEVEL=INFO
+LOG_FILE=chat_agent.log

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+AI[[:space:]]Code[[:space:]]Block[[:space:]]Generation_.docx filter=lfs diff=lfs merge=lfs -text
+instance/chat_agent.db filter=lfs diff=lfs merge=lfs -text
+Refine[[:space:]]Scratch[[:space:]]Block[[:space:]]Builders_.docx filter=lfs diff=lfs merge=lfs -text

AI Code Block Generation_.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bc9d14e1a3ef23a5581cf3a000d6d0275f5a85778bf10b08f90891da3997b467
+size 6226103

DEPLOYMENT_README.md

@@ -0,0 +1,403 @@
+# Multi-Language Chat Agent - Deployment Setup
+
+This document provides a comprehensive overview of the deployment configuration and setup for the Multi-Language Chat Agent application.
+
+## 🚀 Quick Start
+
+### Docker Deployment (Recommended)
+
+```bash
+# Clone repository
+git clone <repository-url>
+cd chat-agent
+
+# Set up environment
+cp config/production.env .env
+# Edit .env with your actual values
+
+# Start with Docker Compose
+docker-compose up -d
+
+# Check health
+curl http://localhost:5000/health/
+```
+
+### Manual Deployment
+
+```bash
+# Set up environment
+python scripts/setup_environment.py --environment production
+
+# Start application
+make run-prod
+```
+
+## 📁 Configuration Files Overview
+
+### Docker Configuration
+
+| File | Purpose | Environment |
+|------|---------|-------------|
+| `Dockerfile` | Production container build | Production |
+| `Dockerfile.dev` | Development container with hot reload | Development |
+| `docker-compose.yml` | Production services orchestration | Production |
+| `docker-compose.dev.yml` | Development services with volumes | Development |
+| `nginx.conf` | Reverse proxy configuration | Production |
+| `.dockerignore` | Docker build optimization | All |
+
+### Environment Configuration
+
+| File | Purpose | Usage |
+|------|---------|-------|
+| `config/development.env` | Development environment variables | Development |
+| `config/production.env` | Production environment template | Production |
+| `config/testing.env` | Testing environment configuration | Testing |
+| `.env.example` | Environment template with examples | Reference |
+
+### Database Configuration
+
+| File | Purpose | Usage |
+|------|---------|-------|
+| `migrations/001_initial_schema.sql` | Database schema definition | All environments |
+| `migrations/migrate.py` | Migration management script | All environments |
+| `scripts/init_db.py` | Database initialization utility | Setup |
+
+### Deployment Scripts
+
+| File | Purpose | Usage |
+|------|---------|-------|
+| `scripts/setup_environment.py` | Automated environment setup | Setup |
+| `scripts/init_db.py` | Database management | Setup/Maintenance |
+| `Makefile` | Common development tasks | Development |
+
+## 🏗️ Architecture Overview
+
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│     Nginx       │    │   Chat Agent    │    │   PostgreSQL    │
+│  (Reverse Proxy)│────│   Application   │────│   Database      │
+│                 │    │                 │    │                 │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+                                │
+                                │
+                       ┌─────────────────┐
+                       │     Redis       │
+                       │   (Cache/       │
+                       │   Sessions)     │
+                       └─────────────────┘
+```
+
+## 🔧 Configuration Management
+
+### Environment-Specific Settings
+
+The application supports three environments with different configurations:
+
+#### Development
+- Debug mode enabled
+- Detailed logging
+- Local database
+- Hot reload
+- Development tools
+
+#### Production
+- Optimized for performance
+- Security hardened
+- Production database
+- Monitoring enabled
+- Error handling
+
+#### Testing
+- In-memory database
+- Isolated test data
+- Minimal logging
+- Fast execution
+
+### Configuration Hierarchy
+
+1. **Environment Variables** (highest priority)
+2. **`.env` file**
+3. **Config class defaults**
+4. **Application defaults** (lowest priority)
+
+## 🐳 Docker Deployment
+
+### Production Deployment
+
+```bash
+# Build and start all services
+docker-compose up -d
+
+# With nginx reverse proxy
+docker-compose --profile production up -d
+
+# Scale application instances
+docker-compose up -d --scale chat-agent=3
+```
+
+### Development Deployment
+
+```bash
+# Start development environment
+docker-compose -f docker-compose.dev.yml up -d
+
+# View logs
+docker-compose -f docker-compose.dev.yml logs -f
+```
+
+### Docker Services
+
+| Service | Purpose | Ports | Dependencies |
+|---------|---------|-------|--------------|
+| `chat-agent` | Main application | 5000 | postgres, redis |
+| `postgres` | Database | 5432 | - |
+| `redis` | Cache/Sessions | 6379 | - |
+| `nginx` | Reverse proxy | 80, 443 | chat-agent |
+
+## 🗄️ Database Management
+
+### Initialization
+
+```bash
+# Initialize database with schema
+python scripts/init_db.py init --config production
+
+# Check migration status
+python scripts/init_db.py status --config production
+
+# Seed with sample data
+python scripts/init_db.py seed --config production
+```
+
+### Migrations
+
+```bash
+# Run migrations manually
+python migrations/migrate.py migrate --config production
+
+# Check migration status
+python migrations/migrate.py status --config production
+```
+
+### Backup and Restore
+
+```bash
+# Create backup
+make backup-db
+
+# Restore from backup
+make restore-db
+```
+
+## 🔍 Health Monitoring
+
+### Health Check Endpoints
+
+| Endpoint | Purpose | Use Case |
+|----------|---------|----------|
+| `/health/` | Basic health check | Load balancer |
+| `/health/detailed` | Component status | Monitoring |
+| `/health/ready` | Readiness probe | Kubernetes |
+| `/health/live` | Liveness probe | Kubernetes |
+| `/health/metrics` | Application metrics | Monitoring |
+
+### Example Health Check
+
+```bash
+# Basic health check
+curl http://localhost:5000/health/
+
+# Detailed status
+curl http://localhost:5000/health/detailed | jq
+```
+
+### Monitoring Integration
+
+The health endpoints are designed to work with:
+- **Load Balancers**: Nginx, HAProxy, AWS ALB
+- **Container Orchestration**: Kubernetes, Docker Swarm
+- **Monitoring Systems**: Prometheus, Grafana, DataDog
+
+## 🔒 Security Configuration
+
+### Production Security Checklist
+
+- [ ] **HTTPS**: SSL/TLS certificates configured
+- [ ] **API Keys**: Stored securely, not in code
+- [ ] **Database**: Connection encryption enabled
+- [ ] **Firewall**: Proper rules configured
+- [ ] **Headers**: Security headers set in Nginx
+- [ ] **Rate Limiting**: Configured for API endpoints
+- [ ] **Input Validation**: All inputs sanitized
+- [ ] **Logging**: Security events logged
+
+### Environment Variables Security
+
+```bash
+# Use secure secret generation
+python -c "import secrets; print(secrets.token_urlsafe(32))"
+
+# Store in secure location
+export SECRET_KEY="your_secure_key"
+export GROQ_API_KEY="your_api_key"
+```
+
+## 📊 Performance Optimization
+
+### Application Performance
+
+- **Connection Pooling**: Database and Redis connections
+- **Caching**: Redis for sessions and frequent data
+- **Async Processing**: WebSocket for real-time communication
+- **Load Balancing**: Multiple application instances
+
+### Database Performance
+
+```sql
+-- Recommended indexes
+CREATE INDEX CONCURRENTLY idx_messages_session_timestamp 
+ON messages(session_id, timestamp);
+
+CREATE INDEX CONCURRENTLY idx_sessions_user_active 
+ON chat_sessions(user_id, is_active);
+```
+
+### Redis Configuration
+
+```bash
+# Production Redis settings
+maxmemory 512mb
+maxmemory-policy allkeys-lru
+save 900 1
+save 300 10
+```
+
+## 🚨 Troubleshooting
+
+### Common Issues
+
+#### 1. Container Won't Start
+
+```bash
+# Check logs
+docker-compose logs chat-agent
+
+# Check health
+docker-compose exec chat-agent curl localhost:5000/health/
+```
+
+#### 2. Database Connection Failed
+
+```bash
+# Test database connectivity
+docker-compose exec postgres psql -U chatuser -d chat_agent_db -c "SELECT 1;"
+
+# Check environment variables
+docker-compose exec chat-agent env | grep DATABASE
+```
+
+#### 3. Redis Connection Issues
+
+```bash
+# Test Redis connectivity
+docker-compose exec redis redis-cli ping
+
+# Check Redis logs
+docker-compose logs redis
+```
+
+### Log Analysis
+
+```bash
+# Application logs
+docker-compose logs -f chat-agent
+
+# Database logs
+docker-compose logs -f postgres
+
+# All services
+docker-compose logs -f
+```
+
+## 📈 Scaling
+
+### Horizontal Scaling
+
+```bash
+# Scale application instances
+docker-compose up -d --scale chat-agent=3
+
+# Update nginx upstream configuration
+# Add multiple server entries in nginx.conf
+```
+
+### Load Balancing
+
+```nginx
+upstream chat_agent {
+    server chat-agent_1:5000;
+    server chat-agent_2:5000;
+    server chat-agent_3:5000;
+}
+```
+
+### Database Scaling
+
+- **Read Replicas**: For read-heavy workloads
+- **Connection Pooling**: PgBouncer for connection management
+- **Partitioning**: For large message tables
+
+## 🔄 CI/CD Integration
+
+### GitHub Actions Example
+
+```yaml
+name: Deploy to Production
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      
+      - name: Build and Deploy
+        run: |
+          docker-compose build
+          docker-compose up -d
+          
+      - name: Health Check
+        run: |
+          sleep 30
+          curl -f http://localhost:5000/health/ || exit 1
+```
+
+## 📚 Additional Resources
+
+- **[Deployment Guide](docs/DEPLOYMENT.md)**: Detailed deployment instructions
+- **[Environment Setup](docs/ENVIRONMENT_SETUP.md)**: Manual setup guide
+- **[API Documentation](chat_agent/api/README.md)**: API reference
+- **[Feature Specifications](.kiro/specs/multi-language-chat-agent/)**: Requirements and design
+
+## 🆘 Support
+
+For deployment issues:
+
+1. Check the [troubleshooting section](#-troubleshooting)
+2. Review application logs
+3. Verify configuration settings
+4. Test health endpoints
+5. Check system resources
+
+## 📝 Changelog
+
+### Version 1.0.0
+- Initial deployment configuration
+- Docker containerization
+- Health monitoring
+- Environment management
+- Database migrations
+- Security hardening

Dockerfile

@@ -0,0 +1,51 @@
+# Multi-stage build for production optimization
+FROM python:3.11-slim as builder
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies for building Python packages
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    libpq-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir --user -r requirements.txt
+
+# Production stage
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install runtime dependencies
+RUN apt-get update && apt-get install -y \
+    libpq5 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy Python packages from builder stage
+COPY --from=builder /root/.local /root/.local
+
+# Make sure scripts in .local are usable
+ENV PATH=/root/.local/bin:$PATH
+
+# Copy application code
+COPY . .
+
+# Create non-root user for security
+RUN groupadd -r chatuser && useradd -r -g chatuser chatuser
+RUN chown -R chatuser:chatuser /app
+USER chatuser
+
+# Expose port
+EXPOSE 5000
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD python -c "import requests; requests.get('http://localhost:5000/health')" || exit 1
+
+# Default command
+CMD ["python", "app.py"]

Dockerfile.dev

@@ -0,0 +1,31 @@
+# Development Dockerfile with hot reload
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    libpq-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Install development dependencies
+RUN pip install --no-cache-dir \
+    watchdog \
+    flask-debugtoolbar \
+    ipdb
+
+# Copy application code
+COPY . .
+
+# Expose port
+EXPOSE 5000
+
+# Development command with hot reload
+CMD ["python", "-m", "flask", "run", "--host=0.0.0.0", "--port=5000", "--reload"]

FRONTEND_README.md

@@ -0,0 +1,160 @@
+# Chat Interface Frontend
+
+This document describes the frontend chat interface implementation for the multi-language chat agent.
+
+## Features Implemented
+
+### ✅ Responsive Chat UI
+- Clean, modern interface with gradient header
+- Responsive design that works on desktop and mobile
+- Dark mode support via CSS media queries
+- Smooth animations and transitions
+
+### ✅ WebSocket Client
+- Real-time communication with backend via Socket.IO
+- Automatic reconnection handling
+- Connection status indicators
+- Error handling and user feedback
+
+### ✅ Language Selection
+- Dropdown with 8 supported programming languages:
+  - Python (default)
+  - JavaScript
+  - Java
+  - C++
+  - C#
+  - Go
+  - Rust
+  - TypeScript
+- Real-time language switching
+- Visual feedback when language changes
+
+### ✅ Syntax Highlighting
+- Prism.js integration for code block highlighting
+- Automatic language detection
+- Support for inline code and code blocks
+- Click-to-copy functionality for code blocks
+
+### ✅ Typing Indicators
+- Visual typing animation while assistant responds
+- Streaming response support with real-time updates
+- Processing status indicators
+
+### ✅ Connection Status
+- Visual connection status indicator (connected/disconnected/connecting)
+- Automatic reconnection attempts
+- Connection health monitoring
+
+### ✅ Error Message Display
+- User-friendly error messages
+- Auto-dismissing error notifications
+- Toast notifications for actions like copying code
+- Character count with warnings
+
+## Files Created
+
+### HTML Template
+- `templates/chat.html` - Main chat interface template
+
+### CSS Styles
+- `static/css/chat.css` - Complete responsive styling with:
+  - Modern gradient design
+  - Responsive breakpoints
+  - Dark mode support
+  - Smooth animations
+  - Code block styling
+
+### JavaScript Client
+- `static/js/chat.js` - WebSocket client with:
+  - ChatClient class for managing connections
+  - Real-time message handling
+  - Language switching
+  - Syntax highlighting integration
+  - Error handling and notifications
+
+## How to Use
+
+1. **Start the Flask Application**
+   ```bash
+   python app.py
+   ```
+
+2. **Open Browser**
+   - Navigate to `http://localhost:5000`
+   - The chat interface will load automatically
+
+3. **Chat Features**
+   - Type messages in the input field
+   - Press Enter to send (Shift+Enter for new lines)
+   - Select different programming languages from dropdown
+   - Click code blocks to copy them
+   - Monitor connection status in header
+
+## Demo Mode
+
+The current implementation includes a demo WebSocket handler that:
+- Simulates streaming responses
+- Handles language switching
+- Provides helpful demo messages
+- Shows all UI features working
+
+## Integration with Backend
+
+The frontend is designed to work with the full chat agent backend. Key integration points:
+
+### WebSocket Events
+- `connect` - Establish connection with auth
+- `message` - Send chat messages
+- `language_switch` - Change programming language
+- `disconnect` - Clean disconnection
+
+### Expected Backend Events
+- `connection_status` - Connection confirmation
+- `response_start` - Begin streaming response
+- `response_chunk` - Stream response content
+- `response_complete` - End streaming response
+- `language_switched` - Language change confirmation
+- `error` - Error notifications
+
+## Browser Compatibility
+
+- Modern browsers with WebSocket support
+- Chrome, Firefox, Safari, Edge
+- Mobile browsers (iOS Safari, Chrome Mobile)
+- Fallback to polling for older browsers
+
+## Performance Features
+
+- Efficient DOM updates
+- Smooth scrolling to new messages
+- Optimized syntax highlighting
+- Minimal memory footprint
+- Automatic cleanup on disconnect
+
+## Security Considerations
+
+- Input sanitization for XSS prevention
+- Message length limits (2000 characters)
+- Rate limiting ready (handled by backend)
+- Secure WebSocket connections (WSS in production)
+
+## Next Steps
+
+The frontend is ready for integration with:
+1. Full chat agent backend (Task 11)
+2. User authentication system
+3. Session persistence
+4. Chat history loading
+5. File upload capabilities
+6. Advanced code execution features
+
+## Testing
+
+The interface has been tested with:
+- WebSocket connection establishment
+- Message sending and receiving
+- Language switching
+- Error handling
+- Responsive design
+- Code copying functionality
+- Real-time streaming responses

Makefile

@@ -0,0 +1,171 @@
+# Makefile for Chat Agent Application
+
+.PHONY: help install setup test clean run docker-build docker-run docker-dev migrate seed
+
+# Default target
+help:
+	@echo "Available commands:"
+	@echo "  install     - Install dependencies"
+	@echo "  setup       - Set up development environment"
+	@echo "  setup-prod  - Set up production environment"
+	@echo "  test        - Run tests"
+	@echo "  test-cov    - Run tests with coverage"
+	@echo "  clean       - Clean up temporary files"
+	@echo "  run         - Run development server"
+	@echo "  run-prod    - Run production server"
+	@echo "  migrate     - Run database migrations"
+	@echo "  seed        - Seed database with sample data"
+	@echo "  reset-db    - Reset database (development only)"
+	@echo "  docker-build - Build Docker image"
+	@echo "  docker-run  - Run with Docker Compose"
+	@echo "  docker-dev  - Run development environment with Docker"
+	@echo "  docker-stop - Stop Docker containers"
+	@echo "  lint        - Run code linting"
+	@echo "  format      - Format code"
+
+# Installation and setup
+install:
+	pip install --upgrade pip
+	pip install -r requirements.txt
+
+setup:
+	python scripts/setup_environment.py --environment development
+
+setup-prod:
+	python scripts/setup_environment.py --environment production
+
+setup-test:
+	python scripts/setup_environment.py --environment testing
+
+# Testing
+test:
+	python -m pytest tests/ -v
+
+test-cov:
+	python -m pytest tests/ --cov=chat_agent --cov-report=html --cov-report=term
+
+test-integration:
+	python -m pytest tests/integration/ -v
+
+test-unit:
+	python -m pytest tests/unit/ -v
+
+# Database operations
+migrate:
+	python scripts/init_db.py init --config development
+
+migrate-prod:
+	python scripts/init_db.py init --config production
+
+seed:
+	python scripts/init_db.py seed --config development
+
+reset-db:
+	python scripts/init_db.py reset --config development
+
+db-status:
+	python scripts/init_db.py status --config development
+
+# Application running
+run:
+	python app.py
+
+run-prod:
+	gunicorn --bind 0.0.0.0:5000 --workers 4 --worker-class eventlet app:app
+
+run-debug:
+	FLASK_DEBUG=True python app.py
+
+# Docker operations
+docker-build:
+	docker build -t chat-agent .
+
+docker-run:
+	docker-compose up -d
+
+docker-dev:
+	docker-compose -f docker-compose.dev.yml up -d
+
+docker-stop:
+	docker-compose down
+	docker-compose -f docker-compose.dev.yml down
+
+docker-logs:
+	docker-compose logs -f chat-agent
+
+docker-clean:
+	docker-compose down -v
+	docker system prune -f
+
+# Code quality
+lint:
+	flake8 chat_agent/ --max-line-length=100 --ignore=E203,W503
+	flake8 tests/ --max-line-length=100 --ignore=E203,W503
+
+format:
+	black chat_agent/ tests/ --line-length=100
+	isort chat_agent/ tests/
+
+type-check:
+	mypy chat_agent/ --ignore-missing-imports
+
+# Cleanup
+clean:
+	find . -type f -name "*.pyc" -delete
+	find . -type d -name "__pycache__" -delete
+	find . -type d -name "*.egg-info" -exec rm -rf {} +
+	rm -rf .coverage htmlcov/ .pytest_cache/ .mypy_cache/
+	rm -rf logs/*.log
+
+clean-all: clean
+	rm -rf venv/
+	rm -rf instance/
+	rm -rf flask_session/
+
+# Health checks
+health:
+	curl -s http://localhost:5000/health/ | python -m json.tool
+
+health-detailed:
+	curl -s http://localhost:5000/health/detailed | python -m json.tool
+
+# Development helpers
+dev-install:
+	pip install -r requirements.txt
+	pip install flask-debugtoolbar ipdb watchdog black flake8 isort mypy
+
+logs:
+	tail -f logs/chat_agent.log
+
+logs-error:
+	tail -f logs/chat_agent.log | grep ERROR
+
+# Production deployment helpers
+deploy-check:
+	@echo "Pre-deployment checklist:"
+	@echo "- [ ] Environment variables configured"
+	@echo "- [ ] Database migrations applied"
+	@echo "- [ ] SSL certificates installed"
+	@echo "- [ ] Firewall configured"
+	@echo "- [ ] Monitoring set up"
+	@echo "- [ ] Backups configured"
+
+backup-db:
+	pg_dump $(DATABASE_URL) > backups/backup_$(shell date +%Y%m%d_%H%M%S).sql
+
+restore-db:
+	@echo "Warning: This will overwrite the current database!"
+	@read -p "Enter backup file path: " backup_file; \
+	psql $(DATABASE_URL) < $$backup_file
+
+# Monitoring
+monitor:
+	watch -n 5 'curl -s http://localhost:5000/health/detailed | python -m json.tool'
+
+# Documentation
+docs:
+	@echo "Documentation available:"
+	@echo "- README.md - Project overview"
+	@echo "- docs/DEPLOYMENT.md - Deployment guide"
+	@echo "- docs/ENVIRONMENT_SETUP.md - Environment setup"
+	@echo "- .kiro/specs/multi-language-chat-agent/ - Feature specifications"

README.md

@@ -1,12 +1,91 @@
----
-title: Scratch Chat
-emoji: 📉
-colorFrom: purple
-colorTo: red
-sdk: docker
-pinned: false
-license: other
-short_description: chat assisstance
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Multi-Language Chat Agent
+
+A Flask-based chat agent that supports multiple programming languages with Python as the default. The agent maintains proper chat history, integrates with Groq LangChain API for LLM capabilities, and provides language-specific assistance to students learning to code.
+
+## Project Structure
+
+```
+chat_agent/
+├── chat_agent/                 # Main application package
+│   ├── __init__.py
+│   ├── api/                    # REST API endpoints
+│   ├── models/                 # Data models
+│   ├── services/               # Business logic services
+│   ├── utils/                  # Utility functions
+│   └── websocket/              # WebSocket handlers
+├── static/                     # Static assets (CSS, JS)
+│   ├── css/
+│   └── js/
+├── templates/                  # HTML templates
+├── tests/                      # Test suite
+│   ├── unit/                   # Unit tests
+│   └── integration/            # Integration tests
+├── app.py                      # Application entry point
+├── config.py                   # Configuration management
+├── requirements.txt            # Python dependencies
+└── .env.example               # Environment variables template
+```
+
+## Setup Instructions
+
+1. **Clone and navigate to the project directory**
+
+2. **Create a virtual environment**
+   ```bash
+   python -m venv venv
+   source venv/bin/activate  # On Windows: venv\Scripts\activate
+   ```
+
+3. **Install dependencies**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+4. **Set up environment variables**
+   ```bash
+   cp .env.example .env
+   # Edit .env with your actual configuration values
+   ```
+
+5. **Set up databases**
+   - Install and start PostgreSQL
+   - Install and start Redis
+   - Update database connection strings in .env
+
+6. **Run the application**
+   ```bash
+   python app.py
+   ```
+
+## Environment Variables
+
+Copy `.env.example` to `.env` and configure the following:
+
+- `GROQ_API_KEY`: Your Groq API key for LLM integration
+- `DATABASE_URL`: PostgreSQL connection string
+- `REDIS_URL`: Redis connection string
+- `SECRET_KEY`: Flask secret key for sessions
+
+## Features
+
+- Multi-language programming support (Python, JavaScript, Java, C++, etc.)
+- Real-time chat with WebSocket communication
+- Persistent chat history with Redis caching
+- Groq LangChain API integration
+- Session management for concurrent users
+- Language context switching mid-conversation
+
+## Development
+
+This project follows the spec-driven development methodology. See the implementation tasks in `.kiro/specs/multi-language-chat-agent/tasks.md` for detailed development steps.
+
+## Testing
+
+Run tests with:
+```bash
+pytest tests/
+```
+
+## License
+
+MIT License

REDIS_SETUP.md

@@ -0,0 +1,237 @@
+# Redis Setup Guide for Chat Agent
+
+## Why Redis is Used
+
+The chat agent uses Redis for several performance and scalability benefits:
+
+1. **Session Caching** - Fast access to frequently used session data
+2. **Chat History Caching** - Quick retrieval of recent messages
+3. **Rate Limiting** - Distributed rate limiting across multiple app instances
+4. **User Session Tracking** - Managing multiple sessions per user
+
+## Error 10061 Explanation
+
+**Error 10061 connecting to localhost:6379** means:
+- Port 6379 is Redis's default port
+- No Redis server is running on your machine
+- The application can't connect to Redis for caching
+
+## Installation Options
+
+### Option 1: Windows Native Installation
+
+1. **Download Redis for Windows:**
+   - Visit: https://github.com/microsoftarchive/redis/releases
+   - Download the latest `.msi` installer
+   - Run the installer and follow the setup wizard
+
+2. **Start Redis:**
+   ```cmd
+   # Redis should start automatically after installation
+   # Or manually start it:
+   redis-server
+   ```
+
+3. **Verify Installation:**
+   ```cmd
+   redis-cli ping
+   # Should return: PONG
+   ```
+
+### Option 2: Using Chocolatey (Windows)
+
+```cmd
+# Install Chocolatey first if you don't have it
+# Then install Redis:
+choco install redis-64
+
+# Start Redis
+redis-server
+
+# Test connection
+redis-cli ping
+```
+
+### Option 3: Using Docker (Recommended)
+
+```bash
+# Pull and run Redis container
+docker run -d -p 6379:6379 --name redis redis:alpine
+
+# Verify it's running
+docker ps
+
+# Test connection
+docker exec -it redis redis-cli ping
+```
+
+### Option 4: WSL/Linux
+
+```bash
+# Update package list
+sudo apt update
+
+# Install Redis
+sudo apt install redis-server
+
+# Start Redis service
+sudo systemctl start redis-server
+
+# Enable auto-start on boot
+sudo systemctl enable redis-server
+
+# Test connection
+redis-cli ping
+```
+
+## Configuration
+
+### Environment Variables
+
+Create a `.env` file in your project root:
+
+```env
+# Redis Configuration
+REDIS_URL=redis://localhost:6379/0
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_DB=0
+REDIS_PASSWORD=
+
+# For production with password:
+# REDIS_URL=redis://:password@localhost:6379/0
+# REDIS_PASSWORD=your-secure-password
+```
+
+### Testing Configuration
+
+For testing without Redis, set:
+
+```env
+REDIS_URL=None
+```
+
+Or use the testing configuration which automatically disables Redis.
+
+## Running Without Redis
+
+The application is designed to work without Redis, but with reduced performance:
+
+### What Works Without Redis:
+- ✅ All API endpoints function normally
+- ✅ Session management (database-only)
+- ✅ Chat history (database-only)
+- ✅ Language context management
+- ✅ Authentication and authorization
+
+### What's Affected Without Redis:
+- ⚠️ **Performance**: Slower session and message retrieval
+- ⚠️ **Rate Limiting**: Uses in-memory storage (not distributed)
+- ⚠️ **Caching**: No caching layer, all requests hit the database
+- ⚠️ **Scalability**: Cannot scale across multiple app instances
+
+### Performance Impact:
+- Session retrieval: ~50-100ms slower per request
+- Chat history: ~100-200ms slower for large histories
+- Rate limiting: Resets when app restarts
+
+## Production Recommendations
+
+### Redis Configuration for Production:
+
+1. **Use a dedicated Redis instance**
+2. **Enable password authentication**
+3. **Configure persistence** (RDB + AOF)
+4. **Set up monitoring**
+5. **Use Redis Cluster** for high availability
+
+### Example Production Config:
+
+```env
+# Production Redis with authentication
+REDIS_URL=redis://:your-secure-password@redis-server:6379/0
+REDIS_PASSWORD=your-secure-password
+
+# Connection pool settings
+REDIS_MAX_CONNECTIONS=20
+REDIS_SOCKET_TIMEOUT=5
+REDIS_SOCKET_CONNECT_TIMEOUT=5
+```
+
+## Troubleshooting
+
+### Common Issues:
+
+1. **"Connection refused" (Error 10061)**
+   - Redis server is not running
+   - Wrong host/port configuration
+   - Firewall blocking the connection
+
+2. **"Authentication failed"**
+   - Wrong password in REDIS_URL
+   - Redis configured with auth but no password provided
+
+3. **"Connection timeout"**
+   - Network issues
+   - Redis server overloaded
+   - Wrong host address
+
+### Debug Commands:
+
+```bash
+# Check if Redis is running
+redis-cli ping
+
+# Check Redis info
+redis-cli info
+
+# Monitor Redis commands
+redis-cli monitor
+
+# Check specific database
+redis-cli -n 0 keys "*"
+```
+
+## Development vs Production
+
+### Development (Local):
+```env
+REDIS_URL=redis://localhost:6379/0
+```
+
+### Testing (No Redis):
+```env
+REDIS_URL=None
+```
+
+### Production (Managed Redis):
+```env
+REDIS_URL=redis://:password@your-redis-host:6379/0
+```
+
+## Cloud Redis Services
+
+For production, consider managed Redis services:
+
+- **AWS ElastiCache**
+- **Google Cloud Memorystore**
+- **Azure Cache for Redis**
+- **Redis Cloud**
+- **DigitalOcean Managed Redis**
+
+These provide:
+- Automatic backups
+- High availability
+- Monitoring and alerts
+- Security and compliance
+- Automatic scaling
+
+## Summary
+
+The **Error 10061** occurs because Redis is not installed or running. You have three options:
+
+1. **Install Redis** (recommended for development/production)
+2. **Use Docker** to run Redis (easiest setup)
+3. **Run without Redis** (works but with performance impact)
+
+The application gracefully handles Redis being unavailable and will continue to function using database-only operations.

Refine Scratch Block Builders_.docx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:40b2b72cc62775bc1e412b0c6985185d36c49e4239f333d3d64f861cc93bb01e
+size 6226907

app.py

@@ -0,0 +1,395 @@
+"""Main application entry point for the multi-language chat agent."""
+
+import os
+from flask import Flask
+from flask_socketio import SocketIO
+from flask_session import Session
+import redis
+
+from config import config
+from chat_agent.models.base import db
+from chat_agent.utils.logging_config import setup_logging
+from chat_agent.utils.error_handler import set_error_handler, ErrorHandler
+from chat_agent.utils.connection_pool import initialize_connection_pools, get_connection_pool_manager
+from chat_agent.services.cache_service import initialize_cache_service, get_cache_service
+from chat_agent.utils.response_optimization import ResponseMiddleware
+
+# Initialize extensions
+socketio = SocketIO()
+session = Session()
+
+
+def create_app(config_name=None):
+    """Application factory pattern."""
+    if config_name is None:
+        config_name = os.getenv('FLASK_ENV', 'development')
+    
+    app = Flask(__name__)
+    app.config.from_object(config[config_name])
+    
+    # Setup comprehensive logging
+    loggers = setup_logging("chat_agent", app.config.get('LOG_LEVEL', 'INFO'))
+    app.logger = loggers['main']
+    
+    # Setup global error handler
+    error_handler = ErrorHandler(loggers['error'])
+    set_error_handler(error_handler)
+    
+    app.logger.info("Chat agent application starting", extra={
+        'config': config_name,
+        'debug': app.config.get('DEBUG', False),
+        'logging_level': app.config.get('LOG_LEVEL', 'INFO')
+    })
+    
+    # Initialize connection pools for performance optimization
+    database_url = app.config.get('SQLALCHEMY_DATABASE_URI')
+    redis_url = app.config.get('REDIS_URL')
+    
+    connection_pool_manager = initialize_connection_pools(database_url, redis_url)
+    
+    # Configure SQLAlchemy to use connection pool
+    if connection_pool_manager:
+        app.config['SQLALCHEMY_ENGINE_OPTIONS'] = {
+            'pool_size': int(os.getenv('DB_POOL_SIZE', '10')),
+            'max_overflow': int(os.getenv('DB_MAX_OVERFLOW', '20')),
+            'pool_recycle': int(os.getenv('DB_POOL_RECYCLE', '3600')),
+            'pool_pre_ping': True,
+            'pool_timeout': int(os.getenv('DB_POOL_TIMEOUT', '30'))
+        }
+    
+    # Initialize extensions with app
+    db.init_app(app)
+    socketio.init_app(app, cors_allowed_origins="*")
+    
+    # Initialize response optimization middleware
+    ResponseMiddleware(app)
+    
+    # Configure Redis for sessions and caching (if available)
+    redis_client = None
+    if redis_url and redis_url != 'None':
+        try:
+            # Use connection pool manager's Redis client if available
+            if connection_pool_manager:
+                redis_client = connection_pool_manager.get_redis_client()
+            else:
+                redis_client = redis.from_url(redis_url)
+            
+            if redis_client:
+                redis_client.ping()  # Test connection
+                app.config['SESSION_REDIS'] = redis_client
+                session.init_app(app)
+                app.logger.info("Redis connection established for sessions and caching")
+            else:
+                raise Exception("Redis client not available")
+                
+        except Exception as e:
+            app.logger.warning(f"Redis connection failed: {e}. Sessions will use filesystem.")
+            app.config['SESSION_TYPE'] = 'filesystem'
+            session.init_app(app)
+            redis_client = None
+    else:
+        app.logger.info("Redis disabled. Using filesystem sessions.")
+        app.config['SESSION_TYPE'] = 'filesystem'
+        session.init_app(app)
+    
+    # Initialize cache service with Redis client
+    cache_service = initialize_cache_service(redis_client)
+    app.logger.info(f"Cache service initialized", extra={
+        'redis_enabled': bool(redis_client)
+    })
+    
+    # Register API blueprints
+    from chat_agent.api import chat_bp, create_limiter, setup_error_handlers, RequestLoggingMiddleware
+    from chat_agent.api.health import health_bp
+    from chat_agent.api.performance_routes import performance_bp
+    app.register_blueprint(chat_bp)
+    app.register_blueprint(health_bp)
+    app.register_blueprint(performance_bp)
+    
+    # Configure rate limiting
+    limiter = create_limiter(app)
+    if redis_url and redis_url != 'None':
+        limiter.storage_uri = redis_url
+    # If no Redis, limiter will use in-memory storage (with warning)
+    
+    # Setup error handlers
+    setup_error_handlers(app)
+    
+    # Setup request logging middleware
+    RequestLoggingMiddleware(app)
+    
+    # Add chat interface route
+    @app.route('/')
+    @app.route('/chat')
+    def chat_interface():
+        """Serve the chat interface."""
+        from flask import render_template
+        return render_template('chat.html')
+    
+    # Initialize real chat agent services
+    from chat_agent.services.groq_client import GroqClient
+    from chat_agent.services.language_context import LanguageContextManager
+    from chat_agent.services.session_manager import SessionManager
+    from chat_agent.services.chat_history import ChatHistoryManager
+    from chat_agent.services.chat_agent import ChatAgent
+    from chat_agent.services.programming_assistance import ProgrammingAssistanceService
+    
+    # Initialize services
+    try:
+        # Initialize Redis client
+        redis_url = app.config.get('REDIS_URL', 'redis://localhost:6379/0')
+        redis_client = redis.from_url(redis_url)
+        
+        # Test Redis connection
+        redis_client.ping()
+        print("✅ Redis connection successful")
+        
+        groq_client = GroqClient()
+        language_context_manager = LanguageContextManager()
+        session_manager = SessionManager(redis_client)
+        chat_history_manager = ChatHistoryManager(redis_client)
+        programming_assistance_service = ProgrammingAssistanceService()
+        
+        # Initialize main chat agent
+        chat_agent = ChatAgent(
+            groq_client=groq_client,
+            language_context_manager=language_context_manager,
+            session_manager=session_manager,
+            chat_history_manager=chat_history_manager,
+            programming_assistance_service=programming_assistance_service
+        )
+        
+        print("✅ Chat agent services initialized successfully")
+        
+    except Exception as e:
+        print(f"⚠️ Error initializing chat agent services: {e}")
+        print("🔄 Falling back to demo mode")
+        chat_agent = None
+    
+    # Store session mapping for WebSocket connections
+    websocket_sessions = {}
+    
+    # Initialize WebSocket handlers for chat interface
+    @socketio.on('connect')
+    def handle_connect(auth=None):
+        """Handle WebSocket connection for chat interface."""
+        from flask_socketio import emit
+        from flask import request
+        import uuid
+        
+        try:
+            # Create a new session for this connection
+            user_id = f"user_{request.sid}"  # Use socket ID as user ID for demo
+            
+            if chat_agent and session_manager:
+                session = session_manager.create_session(user_id, language='python')
+                websocket_sessions[request.sid] = session.id
+                
+                emit('connection_status', {
+                    'status': 'connected',
+                    'session_id': session.id,
+                    'language': session.language,
+                    'message_count': session.message_count,
+                    'timestamp': datetime.now().isoformat()
+                })
+                
+                print(f"WebSocket connected: session={session.id}, user={user_id}")
+            else:
+                # Fallback to demo mode
+                session_id = str(uuid.uuid4())
+                websocket_sessions[request.sid] = session_id
+                
+                emit('connection_status', {
+                    'status': 'connected',
+                    'session_id': session_id,
+                    'language': 'python',
+                    'message_count': 0,
+                    'timestamp': datetime.now().isoformat()
+                })
+                
+                print(f"WebSocket connected (demo mode): session={session_id}, user={user_id}")
+                
+        except Exception as e:
+            print(f"Error connecting WebSocket: {e}")
+            emit('error', {'message': 'Connection failed', 'code': 'CONNECTION_ERROR'})
+    
+    @socketio.on('disconnect')
+    def handle_disconnect(reason=None):
+        """Handle WebSocket disconnection."""
+        from flask import request
+        
+        # Clean up session mapping
+        if request.sid in websocket_sessions:
+            session_id = websocket_sessions[request.sid]
+            del websocket_sessions[request.sid]
+            print(f"WebSocket disconnected: session={session_id}")
+        else:
+            print("WebSocket disconnected")
+    
+    @socketio.on('message')
+    def handle_message(data):
+        """Handle chat messages using real chat agent."""
+        from flask_socketio import emit
+        from flask import request
+        
+        try:
+            print(f"Received message: {data}")
+            
+            # Get session ID for this connection
+            if request.sid not in websocket_sessions:
+                emit('error', {'message': 'No active session', 'code': 'NO_SESSION'})
+                return
+            
+            session_id = websocket_sessions[request.sid]
+            content = data.get('content', '').strip()
+            language = data.get('language', 'python')
+            
+            if not content:
+                emit('error', {'message': 'Empty message received', 'code': 'EMPTY_MESSAGE'})
+                return
+            
+            # Process message with real chat agent
+            emit('response_start', {
+                'session_id': session_id,
+                'language': language,
+                'timestamp': datetime.now().isoformat()
+            })
+            
+            try:
+                if chat_agent:
+                    # Use the real chat agent to process the message
+                    print(f"🤖 Processing message with chat agent: '{content}' (language: {language})")
+                    result = chat_agent.process_message(session_id, content, language)
+                    
+                    # Extract response content from the result dictionary
+                    if isinstance(result, dict) and 'response' in result:
+                        response = result['response']
+                        print(f"✅ Chat agent response: {response[:100]}..." if len(response) > 100 else f"✅ Chat agent response: {response}")
+                    else:
+                        print(f"✅ Unexpected response format: {type(result)}, value: {result}")
+                        response = str(result)
+                else:
+                    # Fallback response if chat agent is not available
+                    response = f"I understand you're asking about: '{content}'. I'm currently in demo mode, but I can help you with {language} programming concepts, debugging, and best practices. The full AI-powered assistant will provide more detailed responses."
+                
+                # Ensure response is a string before processing
+                if not isinstance(response, str):
+                    response = str(response)
+                
+                # Send response in chunks to simulate streaming
+                words = response.split()
+                chunk_size = 5
+                total_chunks = (len(words) + chunk_size - 1) // chunk_size
+                
+                for i in range(0, len(words), chunk_size):
+                    chunk = ' '.join(words[i:i+chunk_size]) + ' '
+                    emit('response_chunk', {
+                        'content': chunk,
+                        'timestamp': datetime.now().isoformat()
+                    })
+                    socketio.sleep(0.02)  # Small delay for streaming effect
+                
+                emit('response_complete', {
+                    'message_id': str(uuid.uuid4()),
+                    'total_chunks': total_chunks,
+                    'processing_time': 1.0,
+                    'timestamp': datetime.now().isoformat()
+                })
+                
+            except Exception as e:
+                print(f"❌ Error processing message with chat agent: {e}")
+                # Fallback to demo response if chat agent fails
+                demo_response = f"I apologize, but I'm having trouble processing your request right now. You asked about: '{content}'. Please try again in a moment, or check that the Groq API key is properly configured."
+                
+                emit('response_chunk', {
+                    'content': demo_response,
+                    'timestamp': datetime.now().isoformat()
+                })
+                
+                emit('response_complete', {
+                    'message_id': str(uuid.uuid4()),
+                    'total_chunks': 1,
+                    'processing_time': 0.1,
+                    'timestamp': datetime.now().isoformat()
+                })
+            
+        except Exception as e:
+            print(f"Error handling message: {e}")
+            emit('error', {'message': 'Failed to process message', 'code': 'PROCESSING_ERROR'})
+    
+    @socketio.on('language_switch')
+    def handle_language_switch(data):
+        """Handle language switching using real chat agent."""
+        from flask_socketio import emit
+        from flask import request
+        
+        try:
+            # Get session ID for this connection
+            if request.sid not in websocket_sessions:
+                emit('error', {'message': 'No active session', 'code': 'NO_SESSION'})
+                return
+            
+            session_id = websocket_sessions[request.sid]
+            new_language = data.get('language', 'python')
+            
+            language_names = {
+                'python': 'Python',
+                'javascript': 'JavaScript', 
+                'java': 'Java',
+                'cpp': 'C++',
+                'csharp': 'C#',
+                'go': 'Go',
+                'rust': 'Rust',
+                'typescript': 'TypeScript'
+            }
+            
+            try:
+                if chat_agent:
+                    # Use real chat agent to switch language
+                    result = chat_agent.switch_language(session_id, new_language)
+                    
+                    emit('language_switched', {
+                        'previous_language': result.get('previous_language', 'python'),
+                        'new_language': result.get('new_language', new_language),
+                        'message': result.get('message', f'Language switched to {language_names.get(new_language, new_language)}'),
+                        'timestamp': datetime.now().isoformat()
+                    })
+                    
+                    print(f"🔄 Language switched to: {new_language} for session {session_id}")
+                else:
+                    # Fallback for demo mode
+                    emit('language_switched', {
+                        'previous_language': 'python',
+                        'new_language': new_language,
+                        'message': f"Switched to {language_names.get(new_language, new_language)}. I'm now ready to help you with {language_names.get(new_language, new_language)} programming!",
+                        'timestamp': datetime.now().isoformat()
+                    })
+                    
+                    print(f"🔄 Language switched to: {new_language} (demo mode)")
+                    
+            except Exception as e:
+                print(f"❌ Error switching language: {e}")
+                emit('error', {'message': 'Failed to switch language', 'code': 'LANGUAGE_SWITCH_ERROR'})
+                
+        except Exception as e:
+            print(f"Error handling language switch: {e}")
+            emit('error', {'message': 'Failed to switch language', 'code': 'LANGUAGE_SWITCH_ERROR'})
+    
+    # Add error handlers for WebSocket
+    @socketio.on_error_default
+    def default_error_handler(e):
+        """Handle WebSocket errors."""
+        print(f"WebSocket error: {e}")
+        from flask_socketio import emit
+        emit('error', {'message': 'Connection error occurred', 'code': 'WEBSOCKET_ERROR'})
+    
+    # Import datetime for timestamps
+    from datetime import datetime
+    import uuid
+    
+    return app
+
+
+if __name__ == '__main__':
+    app = create_app()
+    socketio.run(app, debug=True, host='0.0.0.0', port=5000)

blocks/blocks.json

@@ -0,0 +1,2221 @@
+{
+    "motion_movesteps": {
+        "opcode": "motion_movesteps",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "STEPS": [
+                1,
+                [
+                    4,
+                    "10"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 464,
+        "y": -416
+    },
+    "motion_turnright": {
+        "opcode": "motion_turnright",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "DEGREES": [
+                1,
+                [
+                    4,
+                    "15"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 467,
+        "y": -316
+    },
+    "motion_turnleft": {
+        "opcode": "motion_turnleft",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "DEGREES": [
+                1,
+                [
+                    4,
+                    "15"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 464,
+        "y": -210
+    },
+    "motion_goto": {
+        "opcode": "motion_goto",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "TO": [
+                1,
+                "@iM=Z?~GCbpC}gT7KAKY"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 465,
+        "y": -95
+    },
+    "motion_goto_menu": {
+        "opcode": "motion_goto_menu",
+        "next": null,
+        "parent": "d|J?C902/xy6tD5,|dmB",
+        "inputs": {},
+        "fields": {
+            "TO": [
+                "_random_",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "motion_gotoxy": {
+        "opcode": "motion_gotoxy",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "X": [
+                1,
+                [
+                    4,
+                    "0"
+                ]
+            ],
+            "Y": [
+                1,
+                [
+                    4,
+                    "0"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 468,
+        "y": 12
+    },
+    "motion_glideto": {
+        "opcode": "motion_glideto",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "SECS": [
+                1,
+                [
+                    4,
+                    "1"
+                ]
+            ],
+            "TO": [
+                1,
+                "{id to destination position}"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 470,
+        "y": 129
+    },
+    "motion_glideto_menu": {
+        "opcode": "motion_glideto_menu",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "TO": [
+                "_random_",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "motion_glidesecstoxy": {
+        "opcode": "motion_glidesecstoxy",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "SECS": [
+                1,
+                [
+                    4,
+                    "1"
+                ]
+            ],
+            "X": [
+                1,
+                [
+                    4,
+                    "0"
+                ]
+            ],
+            "Y": [
+                1,
+                [
+                    4,
+                    "0"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 476,
+        "y": 239
+    },
+    "motion_pointindirection": {
+        "opcode": "motion_pointindirection",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "DIRECTION": [
+                1,
+                [
+                    8,
+                    "90"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 493,
+        "y": 361
+    },
+    "motion_pointtowards": {
+        "opcode": "motion_pointtowards",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "TOWARDS": [
+                1,
+                "6xQl1pPk%9E~Znhm*:ng"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 492,
+        "y": 463
+    },
+    "motion_pointtowards_menu": {
+        "opcode": "motion_pointtowards_menu",
+        "next": null,
+        "parent": "Ucm$YBs*^9GFTGXCbal@",
+        "inputs": {},
+        "fields": {
+            "TOWARDS": [
+                "_mouse_",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "motion_changexby": {
+        "opcode": "motion_changexby",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "DX": [
+                1,
+                [
+                    4,
+                    "10"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 851,
+        "y": -409
+    },
+    "motion_setx": {
+        "opcode": "motion_setx",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "X": [
+                1,
+                [
+                    4,
+                    "0"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 864,
+        "y": -194
+    },
+    "motion_changeyby": {
+        "opcode": "motion_changeyby",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "DY": [
+                1,
+                [
+                    4,
+                    "10"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 861,
+        "y": -61
+    },
+    "motion_sety": {
+        "opcode": "motion_sety",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "Y": [
+                1,
+                [
+                    4,
+                    "0"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 864,
+        "y": 66
+    },
+    "motion_ifonedgebounce": {
+        "opcode": "motion_ifonedgebounce",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 1131,
+        "y": -397
+    },
+    "motion_setrotationstyle": {
+        "opcode": "motion_setrotationstyle",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "STYLE": [
+                "left-right",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 1128,
+        "y": -287
+    },
+    "motion_xposition": {
+        "opcode": "motion_xposition",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 1193,
+        "y": -136
+    },
+    "motion_yposition": {
+        "opcode": "motion_yposition",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 1181,
+        "y": -64
+    },
+    "motion_direction": {
+        "opcode": "motion_direction",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 1188,
+        "y": 21
+    },
+    "control_wait": {
+        "opcode": "control_wait",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "DURATION": [
+                1,
+                [
+                    5,
+                    "1"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 337,
+        "y": 129
+    },
+    "control_repeat": {
+        "opcode": "control_repeat",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "TIMES": [
+                1,
+                [
+                    6,
+                    "10"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 348,
+        "y": 265
+    },
+    "control_forever": {
+        "opcode": "control_forever",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 334,
+        "y": 439
+    },
+    "control_if": {
+        "opcode": "control_if",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 331,
+        "y": 597
+    },
+    "control_if_else": {
+        "opcode": "control_if_else",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 335,
+        "y": 779
+    },
+    "control_wait_until": {
+        "opcode": "control_wait_until",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 676,
+        "y": 285
+    },
+    "control_repeat_until": {
+        "opcode": "control_repeat_until",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 692,
+        "y": 381
+    },
+    "control_stop": {
+        "opcode": "control_stop",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "STOP_OPTION": [
+                "all",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 708,
+        "y": 545,
+        "mutation": {
+            "tagName": "mutation",
+            "children": [],
+            "hasnext": "false"
+        }
+    },
+    "control_start_as_clone": {
+        "opcode": "control_start_as_clone",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 665,
+        "y": 672
+    },
+    "control_create_clone_of": {
+        "opcode": "control_create_clone_of",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "CLONE_OPTION": [
+                1,
+                "t))DW9(QSKB]3C/3Ou+J"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 648,
+        "y": 797
+    },
+    "control_create_clone_of_menu": {
+        "opcode": "control_create_clone_of_menu",
+        "next": null,
+        "parent": "80yo/}Cw++Z.;x[ohh|7",
+        "inputs": {},
+        "fields": {
+            "CLONE_OPTION": [
+                "_myself_",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "control_delete_this_clone": {
+        "opcode": "control_delete_this_clone",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 642,
+        "y": 914
+    },
+    "event_whenflagclicked": {
+        "opcode": "event_whenflagclicked",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 166,
+        "y": -422
+    },
+    "event_whenkeypressed": {
+        "opcode": "event_whenkeypressed",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "KEY_OPTION": [
+                "space",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 151,
+        "y": -329
+    },
+    "event_whenthisspriteclicked": {
+        "opcode": "event_whenthisspriteclicked",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 156,
+        "y": -223
+    },
+    "event_whenbackdropswitchesto": {
+        "opcode": "event_whenbackdropswitchesto",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "BACKDROP": [
+                "backdrop1",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 148,
+        "y": -101
+    },
+    "event_whengreaterthan": {
+        "opcode": "event_whengreaterthan",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "VALUE": [
+                1,
+                [
+                    4,
+                    "10"
+                ]
+            ]
+        },
+        "fields": {
+            "WHENGREATERTHANMENU": [
+                "LOUDNESS",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 150,
+        "y": 10
+    },
+    "event_whenbroadcastreceived": {
+        "opcode": "event_whenbroadcastreceived",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "BROADCAST_OPTION": [
+                "message1",
+                "5O!nei;S$!c!=hCT}0:a"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 141,
+        "y": 118
+    },
+    "event_broadcast": {
+        "opcode": "event_broadcast",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "BROADCAST_INPUT": [
+                1,
+                [
+                    11,
+                    "message1",
+                    "5O!nei;S$!c!=hCT}0:a"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 151,
+        "y": 229
+    },
+    "event_broadcastandwait": {
+        "opcode": "event_broadcastandwait",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "BROADCAST_INPUT": [
+                1,
+                [
+                    11,
+                    "message1",
+                    "5O!nei;S$!c!=hCT}0:a"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 157,
+        "y": 340
+    },
+    "sensing_touchingobject": {
+        "opcode": "sensing_touchingobject",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "TOUCHINGOBJECTMENU": [
+                1,
+                "xSKW9a+wTnM~h~So8Jc]"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 359,
+        "y": 116
+    },
+    "sensing_touchingobjectmenu": {
+        "opcode": "sensing_touchingobjectmenu",
+        "next": null,
+        "parent": "Y(n,F@BYzwd4CiN|Bh[P",
+        "inputs": {},
+        "fields": {
+            "TOUCHINGOBJECTMENU": [
+                "_mouse_",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "sensing_touchingcolor": {
+        "opcode": "sensing_touchingcolor",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "COLOR": [
+                1,
+                [
+                    9,
+                    "#55b888"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 360,
+        "y": 188
+    },
+    "sensing_coloristouchingcolor": {
+        "opcode": "sensing_coloristouchingcolor",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "COLOR": [
+                1,
+                [
+                    9,
+                    "#d019f2"
+                ]
+            ],
+            "COLOR2": [
+                1,
+                [
+                    9,
+                    "#2b0de3"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 348,
+        "y": 277
+    },
+    "sensing_askandwait": {
+        "opcode": "sensing_askandwait",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "QUESTION": [
+                1,
+                [
+                    10,
+                    "What's your name?"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 338,
+        "y": 354
+    },
+    "sensing_answer": {
+        "opcode": "sensing_answer",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 782,
+        "y": 111
+    },
+    "sensing_keypressed": {
+        "opcode": "sensing_keypressed",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "KEY_OPTION": [
+                1,
+                "SNlf@Im$sv%.6ULi-f3i"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 762,
+        "y": 207
+    },
+    "sensing_keyoptions": {
+        "opcode": "sensing_keyoptions",
+        "next": null,
+        "parent": "7$xEUO.2hH2R6vh!$(Uj",
+        "inputs": {},
+        "fields": {
+            "KEY_OPTION": [
+                "space",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "sensing_mousedown": {
+        "opcode": "sensing_mousedown",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 822,
+        "y": 422
+    },
+    "sensing_mousex": {
+        "opcode": "sensing_mousex",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 302,
+        "y": 528
+    },
+    "sensing_mousey": {
+        "opcode": "sensing_mousey",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 668,
+        "y": 547
+    },
+    "sensing_setdragmode": {
+        "opcode": "sensing_setdragmode",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "DRAG_MODE": [
+                "draggable",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 950,
+        "y": 574
+    },
+    "sensing_loudness": {
+        "opcode": "sensing_loudness",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 658,
+        "y": 703
+    },
+    "sensing_timer": {
+        "opcode": "sensing_timer",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 459,
+        "y": 671
+    },
+    "sensing_resettimer": {
+        "opcode": "sensing_resettimer",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 462,
+        "y": 781
+    },
+    "sensing_of": {
+        "opcode": "sensing_of",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "OBJECT": [
+                1,
+                "t+o*y;iz,!O#aT|qM_+O"
+            ]
+        },
+        "fields": {
+            "PROPERTY": [
+                "backdrop #",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 997,
+        "y": 754
+    },
+    "sensing_of_object_menu": {
+        "opcode": "sensing_of_object_menu",
+        "next": null,
+        "parent": "[4I2wIG/tNc@LQ-;FbsB",
+        "inputs": {},
+        "fields": {
+            "OBJECT": [
+                "_stage_",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "sensing_current": {
+        "opcode": "sensing_current",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "CURRENTMENU": [
+                "YEAR",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 627,
+        "y": 884
+    },
+    "sensing_dayssince2000": {
+        "opcode": "sensing_dayssince2000",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 959,
+        "y": 903
+    },
+    "sensing_username": {
+        "opcode": "sensing_username",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 833,
+        "y": 757
+    },
+    "operator_add": {
+        "opcode": "operator_add",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "NUM1": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ],
+            "NUM2": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 128,
+        "y": 153
+    },
+    "operator_subtract": {
+        "opcode": "operator_subtract",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "NUM1": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ],
+            "NUM2": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 134,
+        "y": 214
+    },
+    "operator_multiply": {
+        "opcode": "operator_multiply",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "NUM1": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ],
+            "NUM2": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 134,
+        "y": 278
+    },
+    "operator_divide": {
+        "opcode": "operator_divide",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "NUM1": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ],
+            "NUM2": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 138,
+        "y": 359
+    },
+    "operator_random": {
+        "opcode": "operator_random",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "FROM": [
+                1,
+                [
+                    4,
+                    "1"
+                ]
+            ],
+            "TO": [
+                1,
+                [
+                    4,
+                    "10"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 311,
+        "y": 157
+    },
+    "operator_gt": {
+        "opcode": "operator_gt",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "OPERAND1": [
+                1,
+                [
+                    10,
+                    ""
+                ]
+            ],
+            "OPERAND2": [
+                1,
+                [
+                    10,
+                    "50"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 348,
+        "y": 217
+    },
+    "operator_lt": {
+        "opcode": "operator_lt",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "OPERAND1": [
+                1,
+                [
+                    10,
+                    ""
+                ]
+            ],
+            "OPERAND2": [
+                1,
+                [
+                    10,
+                    "50"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 345,
+        "y": 286
+    },
+    "operator_equals": {
+        "opcode": "operator_equals",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "OPERAND1": [
+                1,
+                [
+                    10,
+                    ""
+                ]
+            ],
+            "OPERAND2": [
+                1,
+                [
+                    10,
+                    "50"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 345,
+        "y": 372
+    },
+    "operator_and": {
+        "opcode": "operator_and",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 701,
+        "y": 158
+    },
+    "operator_or": {
+        "opcode": "operator_or",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 705,
+        "y": 222
+    },
+    "operator_not": {
+        "opcode": "operator_not",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 734,
+        "y": 283
+    },
+    "operator_join": {
+        "opcode": "operator_join",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "STRING1": [
+                1,
+                [
+                    10,
+                    "apple "
+                ]
+            ],
+            "STRING2": [
+                1,
+                [
+                    10,
+                    "banana"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 663,
+        "y": 378
+    },
+    "operator_letter_of": {
+        "opcode": "operator_letter_of",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "LETTER": [
+                1,
+                [
+                    6,
+                    "1"
+                ]
+            ],
+            "STRING": [
+                1,
+                [
+                    10,
+                    "apple"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 664,
+        "y": 445
+    },
+    "operator_length": {
+        "opcode": "operator_length",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "STRING": [
+                1,
+                [
+                    10,
+                    "apple"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 664,
+        "y": 521
+    },
+    "operator_contains": {
+        "opcode": "operator_contains",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "STRING1": [
+                1,
+                [
+                    10,
+                    "apple"
+                ]
+            ],
+            "STRING2": [
+                1,
+                [
+                    10,
+                    "a"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 634,
+        "y": 599
+    },
+    "operator_mod": {
+        "opcode": "operator_mod",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "NUM1": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ],
+            "NUM2": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 295,
+        "y": 594
+    },
+    "operator_round": {
+        "opcode": "operator_round",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "NUM": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 307,
+        "y": 674
+    },
+    "operator_mathop": {
+        "opcode": "operator_mathop",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "NUM": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ]
+        },
+        "fields": {
+            "OPERATOR": [
+                "abs",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 280,
+        "y": 754
+    },
+    "data_setvariableto": {
+        "opcode": "data_setvariableto",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "VALUE": [
+                1,
+                [
+                    10,
+                    "0"
+                ]
+            ]
+        },
+        "fields": {
+            "VARIABLE": [
+                "my variable",
+                "`jEk@4|i[#Fk?(8x)AV.-my variable"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 348,
+        "y": 241
+    },
+    "data_changevariableby": {
+        "opcode": "data_changevariableby",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "VALUE": [
+                1,
+                [
+                    4,
+                    "1"
+                ]
+            ]
+        },
+        "fields": {
+            "VARIABLE": [
+                "my variable",
+                "`jEk@4|i[#Fk?(8x)AV.-my variable"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 313,
+        "y": 363
+    },
+    "data_showvariable": {
+        "opcode": "data_showvariable",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "VARIABLE": [
+                "my variable",
+                "`jEk@4|i[#Fk?(8x)AV.-my variable"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 415,
+        "y": 473
+    },
+    "data_hidevariable": {
+        "opcode": "data_hidevariable",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "VARIABLE": [
+                "my variable",
+                "`jEk@4|i[#Fk?(8x)AV.-my variable"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 319,
+        "y": 587
+    },
+    "data_addtolist": {
+        "opcode": "data_addtolist",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "ITEM": [
+                1,
+                [
+                    10,
+                    "thing"
+                ]
+            ]
+        },
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 385,
+        "y": 109
+    },
+    "data_deleteoflist": {
+        "opcode": "data_deleteoflist",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "INDEX": [
+                1,
+                [
+                    7,
+                    "1"
+                ]
+            ]
+        },
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 384,
+        "y": 244
+    },
+    "data_deletealloflist": {
+        "opcode": "data_deletealloflist",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 387,
+        "y": 374
+    },
+    "data_insertatlist": {
+        "opcode": "data_insertatlist",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "ITEM": [
+                1,
+                [
+                    10,
+                    "thing"
+                ]
+            ],
+            "INDEX": [
+                1,
+                [
+                    7,
+                    "1"
+                ]
+            ]
+        },
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 366,
+        "y": 527
+    },
+    "data_replaceitemoflist": {
+        "opcode": "data_replaceitemoflist",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "INDEX": [
+                1,
+                [
+                    7,
+                    "1"
+                ]
+            ],
+            "ITEM": [
+                1,
+                [
+                    10,
+                    "thing"
+                ]
+            ]
+        },
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 365,
+        "y": 657
+    },
+    "data_itemoflist": {
+        "opcode": "data_itemoflist",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "INDEX": [
+                1,
+                [
+                    7,
+                    "1"
+                ]
+            ]
+        },
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 862,
+        "y": 117
+    },
+    "data_itemnumoflist": {
+        "opcode": "data_itemnumoflist",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "ITEM": [
+                1,
+                [
+                    10,
+                    "thing"
+                ]
+            ]
+        },
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 883,
+        "y": 238
+    },
+    "data_lengthoflist": {
+        "opcode": "data_lengthoflist",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 876,
+        "y": 342
+    },
+    "data_listcontainsitem": {
+        "opcode": "data_listcontainsitem",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "ITEM": [
+                1,
+                [
+                    10,
+                    "thing"
+                ]
+            ]
+        },
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 871,
+        "y": 463
+    },
+    "data_showlist": {
+        "opcode": "data_showlist",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 931,
+        "y": 563
+    },
+    "data_hidelist": {
+        "opcode": "data_hidelist",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 962,
+        "y": 716
+    },
+    "sound_playuntildone": {
+        "opcode": "sound_playuntildone",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "SOUND_MENU": [
+                1,
+                "4w%pR8G.yD%g-BwCj=uK"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 253,
+        "y": 17
+    },
+    "sound_sounds_menu": {
+        "opcode": "sound_sounds_menu",
+        "next": null,
+        "parent": "Pdc$U;s8e_uUfTX`}jOo",
+        "inputs": {},
+        "fields": {
+            "SOUND_MENU": [
+                "Meow",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "sound_play": {
+        "opcode": "sound_play",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "SOUND_MENU": [
+                1,
+                "i1U{^VHb*2`9?l}=:L)/"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 245,
+        "y": 122
+    },
+    "sound_stopallsounds": {
+        "opcode": "sound_stopallsounds",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 253,
+        "y": 245
+    },
+    "sound_changeeffectby": {
+        "opcode": "sound_changeeffectby",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "VALUE": [
+                1,
+                [
+                    4,
+                    "10"
+                ]
+            ]
+        },
+        "fields": {
+            "EFFECT": [
+                "PITCH",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 653,
+        "y": 14
+    },
+    "sound_seteffectto": {
+        "opcode": "sound_seteffectto",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "VALUE": [
+                1,
+                [
+                    4,
+                    "100"
+                ]
+            ]
+        },
+        "fields": {
+            "EFFECT": [
+                "PITCH",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 653,
+        "y": 139
+    },
+    "sound_cleareffects": {
+        "opcode": "sound_cleareffects",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 651,
+        "y": 242
+    },
+    "sound_changevolumeby": {
+        "opcode": "sound_changevolumeby",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "VOLUME": [
+                1,
+                [
+                    4,
+                    "-10"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 645,
+        "y": 353
+    },
+    "sound_setvolumeto": {
+        "opcode": "sound_setvolumeto",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "VOLUME": [
+                1,
+                [
+                    4,
+                    "100"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 1108,
+        "y": 5
+    },
+    "sound_volume": {
+        "opcode": "sound_volume",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 1136,
+        "y": 123
+    },
+    "looks_sayforsecs": {
+        "opcode": "looks_sayforsecs",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "MESSAGE": [
+                1,
+                [
+                    10,
+                    "Hello!"
+                ]
+            ],
+            "SECS": [
+                1,
+                [
+                    4,
+                    "2"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 408,
+        "y": 91
+    },
+    "looks_say": {
+        "opcode": "looks_say",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "MESSAGE": [
+                1,
+                [
+                    10,
+                    "Hello!"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 413,
+        "y": 213
+    },
+    "looks_thinkforsecs": {
+        "opcode": "looks_thinkforsecs",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "MESSAGE": [
+                1,
+                [
+                    10,
+                    "Hmm..."
+                ]
+            ],
+            "SECS": [
+                1,
+                [
+                    4,
+                    "2"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 413,
+        "y": 317
+    },
+    "looks_think": {
+        "opcode": "looks_think",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "MESSAGE": [
+                1,
+                [
+                    10,
+                    "Hmm..."
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 412,
+        "y": 432
+    },
+    "looks_switchcostumeto": {
+        "opcode": "looks_switchcostumeto",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "COSTUME": [
+                1,
+                "8;bti4wv(iH9nkOacCJ|"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 411,
+        "y": 555
+    },
+    "looks_costume": {
+        "opcode": "looks_costume",
+        "next": null,
+        "parent": "Q#a,6LPWHqo9-0Nu*[SV",
+        "inputs": {},
+        "fields": {
+            "COSTUME": [
+                "costume2",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "looks_nextcostume": {
+        "opcode": "looks_nextcostume",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 419,
+        "y": 687
+    },
+    "looks_switchbackdropto": {
+        "opcode": "looks_switchbackdropto",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "BACKDROP": [
+                1,
+                "-?yeX}29V*wd6W:unW0i"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 901,
+        "y": 91
+    },
+    "looks_backdrops": {
+        "opcode": "looks_backdrops",
+        "next": null,
+        "parent": "`Wm^p~l[(IWzc1|wNv*.",
+        "inputs": {},
+        "fields": {
+            "BACKDROP": [
+                "backdrop1",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "looks_changesizeby": {
+        "opcode": "looks_changesizeby",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "CHANGE": [
+                1,
+                [
+                    4,
+                    "10"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 895,
+        "y": 192
+    },
+    "looks_setsizeto": {
+        "opcode": "looks_setsizeto",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "SIZE": [
+                1,
+                [
+                    4,
+                    "100"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 896,
+        "y": 303
+    },
+    "looks_changeeffectby": {
+        "opcode": "looks_changeeffectby",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "CHANGE": [
+                1,
+                [
+                    4,
+                    "25"
+                ]
+            ]
+        },
+        "fields": {
+            "EFFECT": [
+                "COLOR",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 892,
+        "y": 416
+    },
+    "looks_seteffectto": {
+        "opcode": "looks_seteffectto",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "VALUE": [
+                1,
+                [
+                    4,
+                    "0"
+                ]
+            ]
+        },
+        "fields": {
+            "EFFECT": [
+                "COLOR",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 902,
+        "y": 527
+    },
+    "looks_cleargraphiceffects": {
+        "opcode": "looks_cleargraphiceffects",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 902,
+        "y": 638
+    },
+    "looks_show": {
+        "opcode": "looks_show",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 908,
+        "y": 758
+    },
+    "looks_hide": {
+        "opcode": "looks_hide",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 455,
+        "y": 861
+    },
+    "looks_gotofrontback": {
+        "opcode": "looks_gotofrontback",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "FRONT_BACK": [
+                "front",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 853,
+        "y": 878
+    },
+    "looks_goforwardbackwardlayers": {
+        "opcode": "looks_goforwardbackwardlayers",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "NUM": [
+                1,
+                [
+                    7,
+                    "1"
+                ]
+            ]
+        },
+        "fields": {
+            "FORWARD_BACKWARD": [
+                "forward",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 851,
+        "y": 999
+    },
+    "looks_costumenumbername": {
+        "opcode": "looks_costumenumbername",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "NUMBER_NAME": [
+                "number",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 458,
+        "y": 1007
+    },
+    "looks_backdropnumbername": {
+        "opcode": "looks_backdropnumbername",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "NUMBER_NAME": [
+                "number",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 1242,
+        "y": 753
+    },
+    "looks_size": {
+        "opcode": "looks_size",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 1249,
+        "y": 876
+    }
+}

blocks/boolean_blocks.json

@@ -0,0 +1,281 @@
+{
+  "block_category": "Boolean Blocks",
+  "description": "Boolean blocks are hexagonal in shape. They represent conditions that evaluate to either 'true' or 'false' and are typically used as inputs for control flow blocks.",
+  "blocks": [
+    {
+      "block_name": "<() < ()>",
+      "block_type": "operator",
+      "op_code": "operator_lt",
+      "block_shape": "Boolean Block",
+      "functionality": "Checks if the first value is less than the second.",
+      "inputs": [
+        {"name": "OPERAND1", "type": "any"},
+        {"name": "OPERAND2", "type": "any"}
+      ],
+      "example_standalone": "<(score) < (10)>",
+      "example_with_other_blocks": [
+        {
+          "script": "if <(score) < (10)> then\n  say [Keep trying!] \nend",
+          "explanation": "This script causes the sprite to say 'Keep trying!' if the 'score' variable is less than 10."
+        }
+      ]
+    },
+    {
+      "block_name": "<() = ()>",
+      "block_type": "operator",
+      "op_code": "operator_equals",
+      "block_shape": "Boolean Block",
+      "functionality": "Checks if two values are equal.",
+      "inputs": [
+        {"name": "OPERAND1", "type": "any"},
+        {"name": "OPERAND2", "type": "any"}
+      ],
+      "example_standalone": "<(answer) = (5)>",
+      "example_with_other_blocks": [
+        {
+          "script": "if <(answer) = (5)> then\n  say [Correct!] \nend",
+          "explanation": "This script makes the sprite say 'Correct!' if the value of the 'answer' variable is exactly 5."
+        }
+      ]
+    },
+    {
+      "block_name": "<() > ()>",
+      "block_type": "operator",
+      "op_code": "operator_gt",
+      "block_shape": "Boolean Block",
+      "functionality": "Checks if the first value is greater than the second.",
+      "inputs": [
+        {"name": "OPERAND1", "type": "any"},
+        {"name": "OPERAND2", "type": "any"}
+      ],
+      "example_standalone": "<([health v]) > (0)>",
+      "example_with_other_blocks": [
+        {
+          "script": "if <([health v]) > (0)> then\n  move (10) steps\nelse\n  stop [all v]\nend",
+          "explanation": "This script moves the sprite if its 'health' is greater than 0; otherwise, it stops all scripts."
+        }
+      ]
+    },
+    {
+      "block_name": "<<> and <>>",
+      "block_type": "operator",
+      "op_code": "operator_and",
+      "block_shape": "Boolean Block",
+      "functionality": "Returns 'true' if both provided Boolean conditions are 'true'.",
+      "inputs": [
+        {"name": "OPERAND1", "type": "boolean"},
+        {"name": "OPERAND2", "type": "boolean"}
+      ],
+      "example_standalone": "<<mouse down?> and <touching [mouse-pointer]?> >",
+      "example_with_other_blocks": [
+        {
+          "script": "if <<mouse down?> and <touching [mouse-pointer]?> > then\n  say [You're clicking me!]\nend",
+          "explanation": "This script makes the sprite say 'You're clicking me!' only if the mouse button is pressed AND the mouse pointer is touching the sprite."
+        }
+      ]
+    },
+    {
+      "block_name": "<<> or <>>",
+      "block_type": "operator",
+      "op_code": "operator_or",
+      "block_shape": "Boolean Block",
+      "functionality": "Returns 'true' if at least one of the provided Boolean conditions is 'true'.",
+      "inputs": [
+        {"name": "OPERAND1", "type": "boolean"},
+        {"name": "OPERAND2", "type": "boolean"}
+      ],
+      "example_standalone": "<<key [left arrow v] pressed?> or <key [a v] pressed?>>",
+      "example_with_other_blocks": [
+        {
+          "script": "if <<key [left arrow v] pressed?> or <key [a v] pressed?>> then\n  change x by (-10)\nend",
+          "explanation": "This script moves the sprite left if either the left arrow key OR the 'a' key is pressed."
+        }
+      ]
+    },
+    {
+      "block_name": "<not <>>",
+      "block_type": "operator",
+      "op_code": "operator_not",
+      "block_shape": "Boolean Block",
+      "functionality": "Returns 'true' if the provided Boolean condition is 'false', and 'false' if it is 'true'.",
+      "inputs": [
+        {"name": "OPERAND", "type": "boolean"}
+      ],
+      "example_standalone": "<not <mouse down?>>",
+      "example_with_other_blocks": [
+        {
+          "script": "if <not <touching [Sprite2 v]?>> then\n  say [I'm safe!]\nend",
+          "explanation": "This script makes the sprite say 'I'm safe!' if it is NOT touching 'Sprite2'."
+        }
+      ]
+    },
+    {
+      "block_name": "<() contains ()?>",
+      "block_type": "operator",
+      "op_code": "operator_contains",
+      "block_shape": "Boolean Block",
+      "functionality": "Checks if one string contains another string.",
+      "inputs": [
+        {"name": "STRING1", "type": "string"},
+        {"name": "STRING2", "type": "string"}
+      ],
+      "example_standalone": "<[apple v] contains [a v]?>",
+      "example_with_other_blocks": [
+        {
+          "script": "if <[answer] contains [yes]?> then\n  say [Great!]\nend",
+          "explanation": "This script makes the sprite say 'Great!' if the 'answer' variable contains the substring 'yes'."
+        }
+      ]
+    },
+    {
+      "block_name": "<touching [edge v]?>",
+      "block_type": "Sensing",
+      "op_code": "sensing_touchingobject",
+      "block_shape": "Boolean Block",
+      "functionality": "Checks if its sprite is touching the mouse-pointer, edge, or another specified sprite.",
+      "inputs": [
+        {"name": "TOUCHINGOBJECTMENU", "type": "dropdown", "options": ["mouse-pointer", "edge", "Sprite1", "..." ]}
+      ],
+      "example_standalone": "<touching [edge v]?>",
+      "example_with_other_blocks": [
+        {
+          "script": "if <touching [Sprite v]?> then\n   broadcast [Game Over v] \nend",
+          "explanation": "This script makes the broadcast message 'Game Over' in script if it comes into contact with the sprite."
+        },
+        {
+          "script": "if <touching [edge v]?> then\n  bounce off edge\nend",
+          "explanation": "This script makes the sprite reverse direction if it comes into contact with the edge of the stage."
+        }
+      ]
+    },
+    {
+      "block_name": "<touching color ()?>",
+      "block_type": "Sensing",
+      "op_code": "sensing_touchingcolor",
+      "block_shape": "Boolean Block",
+      "functionality": "Checks whether its sprite is touching a specified color.",
+      "inputs": [
+        {"name": "COLOR", "type": "color"}
+      ],
+      "example_standalone": "<touching color [#FF0000]?>",
+      "example_with_other_blocks": [
+        {
+          "script": "if <touching color [#FF0000]?> then\n  change [health v] by (-1)\nend",
+          "explanation": "This script decreases the 'health' variable by 1 if the sprite touches any red color on the stage."
+        }
+      ]
+    },
+    {
+      "block_name": "<color () is touching ()?>",
+      "block_type": "Sensing",
+      "op_code": "sensing_coloristouchingcolor",
+      "block_shape": "Boolean Block",
+      "functionality": "Checks whether a specific color on its sprite is touching another specified color on the stage or another sprite.",
+      "inputs": [
+        {"name": "COLOR1", "type": "color"},
+        {"name": "COLOR2", "type": "color"}
+      ],
+      "example_standalone": "<color [#00FF00] is touching [#FF0000]?>",
+      "example_with_other_blocks": [
+        {
+          "script": "if <color [#00FF00] is touching [#FF0000]?> then\n  say [Collision!]\nend",
+          "explanation": "This script makes the sprite say 'Collision!' if a green part of the sprite touches a red color elsewhere in the project."
+        }
+      ]
+    },
+    {
+      "block_name": "<key () pressed?>",
+      "block_type": "Sensing",
+      "op_code": "sensing_keypressed",
+      "block_shape": "Boolean Block",
+      "functionality": "Checks if a specified keyboard key is currently being pressed.",
+      "inputs": [
+        {"name": "KEY_OPTION", "type": "dropdown",
+        "options": [
+            "space",
+            "up arrow",
+            "down arrow",
+            "right arrow",
+            "left arrow",
+            "any",
+            "a",
+            "b",
+            "c",
+            "d",
+            "e",
+            "f",
+            "g",
+            "h",
+            "i",
+            "j",
+            "k",
+            "l",
+            "m",
+            "n",
+            "o",
+            "p",
+            "q",
+            "r",
+            "s",
+            "t",
+            "u",
+            "v",
+            "w",
+            "x",
+            "y",
+            "z",
+            "0",
+            "1",
+            "2",
+            "3",
+            "4",
+            "5",
+            "6",
+            "7",
+            "8",
+            "9"
+          ]}
+      ],
+      "example_standalone": "<key [space v] pressed?>",
+      "example_with_other_blocks": [
+        {
+          "script": "forever\n  if <key [space v] pressed?> then\n    broadcast [shoot v]\n  end\nend",
+          "explanation": "This script continuously checks if the space key is pressed and, if so, sends a 'shoot' broadcast."
+        }
+      ]
+    },
+    {
+      "block_name": "<mouse down?>",
+      "block_type": "Sensing",
+      "op_code": "sensing_mousedown",
+      "block_shape": "Boolean Block",
+      "functionality": "Checks if the computer mouse's primary button is being clicked while the cursor is over the stage.",
+      "inputs": null,
+      "example_standalone": "<mouse down?>",
+      "example_with_other_blocks": [
+        {
+          "script": "if <mouse down?> then\n  go to mouse-pointer\nend",
+          "explanation": "This script makes the sprite follow the mouse pointer only when the mouse button is held down."
+        }
+      ]
+    },
+    {
+      "block_name": "<[my list v] contains ()?>",
+      "block_type": "Data",
+      "op_code": "data_listcontainsitem",
+      "block_shape": "Boolean Block",
+      "functionality": "Checks if a list includes a specific item.",
+      "inputs": [
+        {"name": "LIST", "type": "dropdown"},
+        {"name": "ITEM", "type": "any"}
+      ],
+      "example_standalone": "<[inventory v] contains [key]?>",
+      "example_with_other_blocks": [
+        {
+          "script": "if <[inventory v] contains [key]?> then\n  say [You have the key!]\nend",
+          "explanation": "This script makes the sprite say 'You have the key!' if the 'inventory' list contains the item 'key'."
+        }
+      ]
+    }
+  ]
+}

blocks/c_blocks.json

@@ -0,0 +1,105 @@
+{
+  "block_category": "C Blocks",
+  "description": "C blocks are shaped like the letter 'C'. They are used to loop or conditionally execute blocks that are placed within their opening, managing the flow of scripts.",
+  "blocks": [
+    {
+      "block_name": "repeat ()",
+      "block_type": "Control",
+      "block_shape": "C-Block",
+      "op_code": "control_repeat",
+      "functionality": "Repeats the blocks inside it a specified number of times.",
+      "inputs": [
+        {
+          "name": "times",
+          "type": "number"
+        }
+      ],
+      "example_standalone": "repeat (10)",
+      "example_with_other_blocks": [
+        {
+          "script": "when [space v] key pressed\n  repeat (10)\n    move (10) steps\n    wait (0.1) seconds\n  end",
+          "explanation": "This script makes the sprite move 10 steps Ten times, with a short pause after each movement on spacebar pressed."
+        },
+        {
+          "script": "when [up arrow v] key pressed\n  repeat (10)\n    change y by (10)\n    wait (0.1) seconds\n    change y by (10)\n  end",
+          "explanation": "This script makes the sprite jump, with a short pause after each movement on up arrow pressed."
+        }
+      ]
+    },
+    {
+      "block_name": "forever",
+      "block_type": "Control",
+      "block_shape": "C-Block",
+      "op_code": "control_forever",
+      "functionality": "Continuously runs the blocks inside it.",
+      "inputs": null,
+      "example_standalone": "forever",
+      "example_with_other_blocks": [
+        {
+          "script": "when green flag clicked\n  forever\n    move (5) steps\n    if on edge, bounce\n  end",
+          "explanation": "This script makes the sprite move endlessly and bounce off the edges of the stage, creating continuous motion."
+        }
+      ]
+    },
+    {
+      "block_name": "if <> then",
+      "block_type": "Control",
+      "block_shape": "C-Block",
+      "op_code": "control_if",
+      "functionality": "Executes the blocks inside it only if the specified boolean condition is true. [NOTE: it takes boolean blocks as input]",
+      "inputs": [
+        {
+          "name": "condition",
+          "type": "boolean"
+        }
+      ],
+      "example_standalone": "if <touching [mouse-pointer v]?> then",
+      "example_with_other_blocks": [
+        {
+          "script": "forever\n  if <touching [color (red) v]?> then\n    stop [this script v]\n  end",
+          "explanation": "This script continuously checks if the sprite is touching a red color, and if so, it stops the current script."
+        }
+      ]
+    },
+    {
+      "block_name": "if <> then else",
+      "block_type": "Control",
+      "block_shape": "C-Block",
+      "op_code": "control_if_else",
+      "functionality": "Executes one set of blocks if the specified boolean condition is true, and a different set of blocks if the condition is false. [NOTE: it takes boolean blocks as input]",
+      "inputs": [
+        {
+          "name": "condition",
+          "type": "boolean"
+        }
+      ],
+      "example_standalone": "if <score > (10)> then else",
+      "example_with_other_blocks": [
+        {
+          "script": "if <(score) > (10)> then\n  say [You win!] for (2) seconds\nelse\n  say [Keep trying!] for (2) seconds\nend",
+          "explanation": "This script checks the 'score'. If the score is greater than 10, it says 'You win!'; otherwise, it says 'Keep trying!'."
+        }
+      ]
+    },
+    {
+      "block_name": "repeat until <>",
+      "block_type": "Control",
+      "block_shape": "C-Block",
+      "op_code": "control_repeat_until",
+      "functionality": "Repeats the blocks inside it until the specified boolean condition becomes true. [NOTE: it takes boolean blocks as input]",
+      "inputs": [
+        {
+          "name": "condition",
+          "type": "boolean"
+        }
+      ],
+      "example_standalone": "repeat until <touching [edge v]?>",
+      "example_with_other_blocks": [
+        {
+          "script": "repeat until <touching [edge v]?>\n  move (5) steps\nend",
+          "explanation": "This script makes the sprite move 5 steps repeatedly until it touches the edge of the stage."
+        }
+      ]
+    }
+  ]
+}

blocks/cap_blocks.json

@@ -0,0 +1,53 @@
+{
+  "block_category": "Cap Blocks",
+  "description": "Cap blocks have a notch at the top and a flat bottom. They signify the end of a script, preventing any further blocks from being placed below them, and are used to terminate scripts or specific actions.",
+  "blocks": [
+    {
+      "block_name": "stop [v]",
+      "block_type": "Control",
+      "block_shape": "Cap Block (dynamic: can be Stack)",
+      "op_code": "control_stop",
+      "functionality": "Halts all scripts, only the current script, or other scripts within the same sprite. Its shape can dynamically change based on the selected option.",
+      "inputs": [
+        {"name": "option", "type": "dropdown", "options": ["all"]}
+      ],
+      "example_standalone": "stop [all v]",
+      "example_with_other_blocks": [
+        {
+          "script": "if <(health) = (0)> then\n  stop [all v]\nend",
+          "explanation": "This script stops all running scripts in the project if the 'health' variable reaches 0, typically signifying a game over condition. [9, 15]"
+        }
+      ]
+    },
+    {
+      "block_name": "delete this clone",
+      "block_type": "Control",
+      "block_shape": "Cap Block",
+      "op_code": "control_delete_this_clone",
+      "functionality": "Removes the clone that is executing it from the stage.",
+      "inputs":null,
+      "example_standalone": "delete this clone",
+      "example_with_other_blocks": [
+        {
+          "script": "when I start as a clone\n  wait until <touching [edge v]?>\n  delete this clone\nend",
+          "explanation": "This script, run by a clone, causes the clone to disappear from the stage once it touches the edge. [1]"
+        }
+      ]
+    },
+    {
+      "block_name": "forever",
+      "block_type": "Control",
+      "block_shape": "Cap Block",
+      "op_code": "control_forever",
+      "functionality": "Continuously runs the blocks inside it.",
+      "inputs": null,
+      "example_standalone": "forever",
+      "example_with_other_blocks": [
+        {
+          "script": "when green flag clicked\n  forever\n    move (5) steps\n    if on edge, bounce\n  end",
+          "explanation": "This script makes the sprite move endlessly and bounce off the edges of the stage, creating continuous motion."
+        }
+      ]
+    }
+  ]
+}

blocks/classwise_blocks/control_block.json

@@ -0,0 +1,168 @@
+{
+        "control_wait": {
+        "opcode": "control_wait",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "DURATION": [
+                1,
+                [
+                    5,
+                    "1"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 337,
+        "y": 129
+    },
+    "control_repeat": {
+        "opcode": "control_repeat",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "TIMES": [
+                1,
+                [
+                    6,
+                    "10"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 348,
+        "y": 265
+    },
+    "control_forever": {
+        "opcode": "control_forever",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 334,
+        "y": 439
+    },
+    "control_if": {
+        "opcode": "control_if",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 331,
+        "y": 597
+    },
+    "control_if_else": {
+        "opcode": "control_if_else",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 335,
+        "y": 779
+    },
+    "control_wait_until": {
+        "opcode": "control_wait_until",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 676,
+        "y": 285
+    },
+    "control_repeat_until": {
+        "opcode": "control_repeat_until",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 692,
+        "y": 381
+    },
+    "control_stop": {
+        "opcode": "control_stop",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "STOP_OPTION": [
+                "all",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 708,
+        "y": 545,
+        "mutation": {
+            "tagName": "mutation",
+            "children": [],
+            "hasnext": "false"
+        }
+    },
+    "control_start_as_clone": {
+        "opcode": "control_start_as_clone",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 665,
+        "y": 672
+    },
+    "control_create_clone_of": {
+        "opcode": "control_create_clone_of",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "CLONE_OPTION": [
+                1,
+                "control_create_clone_of_menu"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 648,
+        "y": 797
+    },
+    "control_create_clone_of_menu": {
+        "opcode": "control_create_clone_of_menu",
+        "next": null,
+        "parent": "control_create_clone_of",
+        "inputs": {},
+        "fields": {
+            "CLONE_OPTION": [
+                "_myself_",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "control_delete_this_clone": {
+        "opcode": "control_delete_this_clone",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 642,
+        "y": 914
+    }
+}

blocks/classwise_blocks/data_block.json

@@ -0,0 +1,328 @@
+{
+    "data_setvariableto": {
+        "opcode": "data_setvariableto",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "VALUE": [
+                1,
+                [
+                    10,
+                    "0"
+                ]
+            ]
+        },
+        "fields": {
+            "VARIABLE": [
+                "my variable",
+                "`jEk@4|i[#Fk?(8x)AV.-my variable"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 348,
+        "y": 241
+    },
+    "data_changevariableby": {
+        "opcode": "data_changevariableby",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "VALUE": [
+                1,
+                [
+                    4,
+                    "1"
+                ]
+            ]
+        },
+        "fields": {
+            "VARIABLE": [
+                "my variable",
+                "`jEk@4|i[#Fk?(8x)AV.-my variable"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 313,
+        "y": 363
+    },
+    "data_showvariable": {
+        "opcode": "data_showvariable",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "VARIABLE": [
+                "my variable",
+                "`jEk@4|i[#Fk?(8x)AV.-my variable"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 415,
+        "y": 473
+    },
+    "data_hidevariable": {
+        "opcode": "data_hidevariable",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "VARIABLE": [
+                "my variable",
+                "`jEk@4|i[#Fk?(8x)AV.-my variable"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 319,
+        "y": 587
+    },
+    "data_addtolist": {
+        "opcode": "data_addtolist",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "ITEM": [
+                1,
+                [
+                    10,
+                    "thing"
+                ]
+            ]
+        },
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 385,
+        "y": 109
+    },
+    "data_deleteoflist": {
+        "opcode": "data_deleteoflist",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "INDEX": [
+                1,
+                [
+                    7,
+                    "1"
+                ]
+            ]
+        },
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 384,
+        "y": 244
+    },
+    "data_deletealloflist": {
+        "opcode": "data_deletealloflist",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 387,
+        "y": 374
+    },
+    "data_insertatlist": {
+        "opcode": "data_insertatlist",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "ITEM": [
+                1,
+                [
+                    10,
+                    "thing"
+                ]
+            ],
+            "INDEX": [
+                1,
+                [
+                    7,
+                    "1"
+                ]
+            ]
+        },
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 366,
+        "y": 527
+    },
+    "data_replaceitemoflist": {
+        "opcode": "data_replaceitemoflist",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "INDEX": [
+                1,
+                [
+                    7,
+                    "1"
+                ]
+            ],
+            "ITEM": [
+                1,
+                [
+                    10,
+                    "thing"
+                ]
+            ]
+        },
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 365,
+        "y": 657
+    },
+    "data_itemoflist": {
+        "opcode": "data_itemoflist",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "INDEX": [
+                1,
+                [
+                    7,
+                    "1"
+                ]
+            ]
+        },
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 862,
+        "y": 117
+    },
+    "data_itemnumoflist": {
+        "opcode": "data_itemnumoflist",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "ITEM": [
+                1,
+                [
+                    10,
+                    "thing"
+                ]
+            ]
+        },
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 883,
+        "y": 238
+    },
+    "data_lengthoflist": {
+        "opcode": "data_lengthoflist",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 876,
+        "y": 342
+    },
+    "data_listcontainsitem": {
+        "opcode": "data_listcontainsitem",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "ITEM": [
+                1,
+                [
+                    10,
+                    "thing"
+                ]
+            ]
+        },
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 871,
+        "y": 463
+    },
+    "data_showlist": {
+        "opcode": "data_showlist",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 931,
+        "y": 563
+    },
+    "data_hidelist": {
+        "opcode": "data_hidelist",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "LIST": [
+                "MY_LIST",
+                "o6`kIhtT{xWH+rX(5d,A"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 962,
+        "y": 716
+    }
+}

blocks/classwise_blocks/event_block.json

@@ -0,0 +1,136 @@
+{
+    "event_whenflagclicked": {
+        "opcode": "event_whenflagclicked",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 166,
+        "y": -422
+    },
+    "event_whenkeypressed": {
+        "opcode": "event_whenkeypressed",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "KEY_OPTION": [
+                "space",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 151,
+        "y": -329
+    },
+    "event_whenthisspriteclicked": {
+        "opcode": "event_whenthisspriteclicked",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 156,
+        "y": -223
+    },
+    "event_whenbackdropswitchesto": {
+        "opcode": "event_whenbackdropswitchesto",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "BACKDROP": [
+                "backdrop1",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 148,
+        "y": -101
+    },
+    "event_whengreaterthan": {
+        "opcode": "event_whengreaterthan",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "VALUE": [
+                1,
+                [
+                    4,
+                    "10"
+                ]
+            ]
+        },
+        "fields": {
+            "WHENGREATERTHANMENU": [
+                "LOUDNESS",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 150,
+        "y": 10
+    },
+    "event_whenbroadcastreceived": {
+        "opcode": "event_whenbroadcastreceived",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "BROADCAST_OPTION": [
+                "message1",
+                "5O!nei;S$!c!=hCT}0:a"
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 141,
+        "y": 118
+    },
+    "event_broadcast": {
+        "opcode": "event_broadcast",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "BROADCAST_INPUT": [
+                1,
+                [
+                    11,
+                    "message1",
+                    "5O!nei;S$!c!=hCT}0:a"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 151,
+        "y": 229
+    },
+    "event_broadcastandwait": {
+        "opcode": "event_broadcastandwait",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "BROADCAST_INPUT": [
+                1,
+                [
+                    11,
+                    "message1",
+                    "5O!nei;S$!c!=hCT}0:a"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 157,
+        "y": 340
+    }
+}

blocks/classwise_blocks/look_block.json

@@ -0,0 +1,365 @@
+{
+    "looks_sayforsecs": {
+        "opcode": "looks_sayforsecs",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "MESSAGE": [
+                1,
+                [
+                    10,
+                    "Hello!"
+                ]
+            ],
+            "SECS": [
+                1,
+                [
+                    4,
+                    "2"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 408,
+        "y": 91
+    },
+    "looks_say": {
+        "opcode": "looks_say",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "MESSAGE": [
+                1,
+                [
+                    10,
+                    "Hello!"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 413,
+        "y": 213
+    },
+    "looks_thinkforsecs": {
+        "opcode": "looks_thinkforsecs",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "MESSAGE": [
+                1,
+                [
+                    10,
+                    "Hmm..."
+                ]
+            ],
+            "SECS": [
+                1,
+                [
+                    4,
+                    "2"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 413,
+        "y": 317
+    },
+    "looks_think": {
+        "opcode": "looks_think",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "MESSAGE": [
+                1,
+                [
+                    10,
+                    "Hmm..."
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 412,
+        "y": 432
+    },
+    "looks_switchcostumeto": {
+        "opcode": "looks_switchcostumeto",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "COSTUME": [
+                1,
+                "looks_costume"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 411,
+        "y": 555
+    },
+    "looks_costume": {
+        "opcode": "looks_costume",
+        "next": null,
+        "parent": "looks_switchcostumeto",
+        "inputs": {},
+        "fields": {
+            "COSTUME": [
+                "costume2",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "looks_nextcostume": {
+        "opcode": "looks_nextcostume",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 419,
+        "y": 687
+    },
+    "looks_switchbackdropto": {
+        "opcode": "looks_switchbackdropto",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "BACKDROP": [
+                1,
+                "looks_backdrops"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 901,
+        "y": 91
+    },
+    "looks_backdrops": {
+        "opcode": "looks_backdrops",
+        "next": null,
+        "parent": "looks_switchbackdropto",
+        "inputs": {},
+        "fields": {
+            "BACKDROP": [
+                "backdrop1",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "looks_changesizeby": {
+        "opcode": "looks_changesizeby",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "CHANGE": [
+                1,
+                [
+                    4,
+                    "10"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 895,
+        "y": 192
+    },
+    "looks_setsizeto": {
+        "opcode": "looks_setsizeto",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "SIZE": [
+                1,
+                [
+                    4,
+                    "100"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 896,
+        "y": 303
+    },
+    "looks_changeeffectby": {
+        "opcode": "looks_changeeffectby",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "CHANGE": [
+                1,
+                [
+                    4,
+                    "25"
+                ]
+            ]
+        },
+        "fields": {
+            "EFFECT": [
+                "COLOR",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 892,
+        "y": 416
+    },
+    "looks_seteffectto": {
+        "opcode": "looks_seteffectto",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "VALUE": [
+                1,
+                [
+                    4,
+                    "0"
+                ]
+            ]
+        },
+        "fields": {
+            "EFFECT": [
+                "COLOR",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 902,
+        "y": 527
+    },
+    "looks_cleargraphiceffects": {
+        "opcode": "looks_cleargraphiceffects",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 902,
+        "y": 638
+    },
+    "looks_show": {
+        "opcode": "looks_show",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 908,
+        "y": 758
+    },
+    "looks_hide": {
+        "opcode": "looks_hide",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 455,
+        "y": 861
+    },
+    "looks_gotofrontback": {
+        "opcode": "looks_gotofrontback",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "FRONT_BACK": [
+                "front",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 853,
+        "y": 878
+    },
+    "looks_goforwardbackwardlayers": {
+        "opcode": "looks_goforwardbackwardlayers",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "NUM": [
+                1,
+                [
+                    7,
+                    "1"
+                ]
+            ]
+        },
+        "fields": {
+            "FORWARD_BACKWARD": [
+                "forward",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 851,
+        "y": 999
+    },
+    "looks_costumenumbername": {
+        "opcode": "looks_costumenumbername",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "NUMBER_NAME": [
+                "number",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 458,
+        "y": 1007
+    },
+    "looks_backdropnumbername": {
+        "opcode": "looks_backdropnumbername",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "NUMBER_NAME": [
+                "number",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 1242,
+        "y": 753
+    },
+    "looks_size": {
+        "opcode": "looks_size",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 1249,
+        "y": 876
+    }
+}

blocks/classwise_blocks/motion_block.json

@@ -0,0 +1,370 @@
+{
+    "motion_movesteps": {
+        "opcode": "motion_movesteps",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "STEPS": [
+                1,
+                [
+                    4,
+                    "10"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 464,
+        "y": -416
+    },
+    "motion_turnright": {
+        "opcode": "motion_turnright",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "DEGREES": [
+                1,
+                [
+                    4,
+                    "15"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 467,
+        "y": -316
+    },
+    "motion_turnleft": {
+        "opcode": "motion_turnleft",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "DEGREES": [
+                1,
+                [
+                    4,
+                    "15"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 464,
+        "y": -210
+    },
+    "motion_goto": {
+        "opcode": "motion_goto",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "TO": [
+                1,
+                "motion_goto_menu"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 465,
+        "y": -95
+    },
+    "motion_goto_menu": {
+        "opcode": "motion_goto_menu",
+        "next": null,
+        "parent": "motion_goto",
+        "inputs": {},
+        "fields": {
+            "TO": [
+                "_random_",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "motion_gotoxy": {
+        "opcode": "motion_gotoxy",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "X": [
+                1,
+                [
+                    4,
+                    "0"
+                ]
+            ],
+            "Y": [
+                1,
+                [
+                    4,
+                    "0"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 468,
+        "y": 12
+    },
+    "motion_glideto": {
+        "opcode": "motion_glideto",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "SECS": [
+                1,
+                [
+                    4,
+                    "1"
+                ]
+            ],
+            "TO": [
+                1,
+                "motion_glideto_menu"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 470,
+        "y": 129
+    },
+    "motion_glideto_menu": {
+        "opcode": "motion_glideto_menu",
+        "next": null,
+        "parent": "motion_glideto",
+        "inputs": {},
+        "fields": {
+            "TO": [
+                "_random_",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "motion_glidesecstoxy": {
+        "opcode": "motion_glidesecstoxy",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "SECS": [
+                1,
+                [
+                    4,
+                    "1"
+                ]
+            ],
+            "X": [
+                1,
+                [
+                    4,
+                    "0"
+                ]
+            ],
+            "Y": [
+                1,
+                [
+                    4,
+                    "0"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 476,
+        "y": 239
+    },
+    "motion_pointindirection": {
+        "opcode": "motion_pointindirection",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "DIRECTION": [
+                1,
+                [
+                    8,
+                    "90"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 493,
+        "y": 361
+    },
+    "motion_pointtowards": {
+        "opcode": "motion_pointtowards",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "TOWARDS": [
+                1,
+                "6xQl1pPk%9E~Znhm*:ng"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 492,
+        "y": 463
+    },
+    "motion_pointtowards_menu": {
+        "opcode": "motion_pointtowards_menu",
+        "next": null,
+        "parent": "Ucm$YBs*^9GFTGXCbal@",
+        "inputs": {},
+        "fields": {
+            "TOWARDS": [
+                "_mouse_",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "motion_changexby": {
+        "opcode": "motion_changexby",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "DX": [
+                1,
+                [
+                    4,
+                    "10"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 851,
+        "y": -409
+    },
+    "motion_setx": {
+        "opcode": "motion_setx",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "X": [
+                1,
+                [
+                    4,
+                    "0"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 864,
+        "y": -194
+    },
+    "motion_changeyby": {
+        "opcode": "motion_changeyby",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "DY": [
+                1,
+                [
+                    4,
+                    "10"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 861,
+        "y": -61
+    },
+    "motion_sety": {
+        "opcode": "motion_sety",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "Y": [
+                1,
+                [
+                    4,
+                    "0"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 864,
+        "y": 66
+    },
+    "motion_ifonedgebounce": {
+        "opcode": "motion_ifonedgebounce",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 1131,
+        "y": -397
+    },
+    "motion_setrotationstyle": {
+        "opcode": "motion_setrotationstyle",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "STYLE": [
+                "left-right",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 1128,
+        "y": -287
+    },
+    "motion_xposition": {
+        "opcode": "motion_xposition",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 1193,
+        "y": -136
+    },
+    "motion_yposition": {
+        "opcode": "motion_yposition",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 1181,
+        "y": -64
+    },
+    "motion_direction": {
+        "opcode": "motion_direction",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 1188,
+        "y": 21
+    }
+}

blocks/classwise_blocks/operator_block.json

@@ -0,0 +1,409 @@
+{
+    "operator_add": {
+        "opcode": "operator_add",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "NUM1": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ],
+            "NUM2": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 128,
+        "y": 153
+    },
+    "operator_subtract": {
+        "opcode": "operator_subtract",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "NUM1": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ],
+            "NUM2": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 134,
+        "y": 214
+    },
+    "operator_multiply": {
+        "opcode": "operator_multiply",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "NUM1": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ],
+            "NUM2": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 134,
+        "y": 278
+    },
+    "operator_divide": {
+        "opcode": "operator_divide",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "NUM1": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ],
+            "NUM2": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 138,
+        "y": 359
+    },
+    "operator_random": {
+        "opcode": "operator_random",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "FROM": [
+                1,
+                [
+                    4,
+                    "1"
+                ]
+            ],
+            "TO": [
+                1,
+                [
+                    4,
+                    "10"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 311,
+        "y": 157
+    },
+    "operator_gt": {
+        "opcode": "operator_gt",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "OPERAND1": [
+                1,
+                [
+                    10,
+                    ""
+                ]
+            ],
+            "OPERAND2": [
+                1,
+                [
+                    10,
+                    "50"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 348,
+        "y": 217
+    },
+    "operator_lt": {
+        "opcode": "operator_lt",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "OPERAND1": [
+                1,
+                [
+                    10,
+                    ""
+                ]
+            ],
+            "OPERAND2": [
+                1,
+                [
+                    10,
+                    "50"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 345,
+        "y": 286
+    },
+    "operator_equals": {
+        "opcode": "operator_equals",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "OPERAND1": [
+                1,
+                [
+                    10,
+                    ""
+                ]
+            ],
+            "OPERAND2": [
+                1,
+                [
+                    10,
+                    "50"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 345,
+        "y": 372
+    },
+    "operator_and": {
+        "opcode": "operator_and",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 701,
+        "y": 158
+    },
+    "operator_or": {
+        "opcode": "operator_or",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 705,
+        "y": 222
+    },
+    "operator_not": {
+        "opcode": "operator_not",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 734,
+        "y": 283
+    },
+    "operator_join": {
+        "opcode": "operator_join",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "STRING1": [
+                1,
+                [
+                    10,
+                    "apple "
+                ]
+            ],
+            "STRING2": [
+                1,
+                [
+                    10,
+                    "banana"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 663,
+        "y": 378
+    },
+    "operator_letter_of": {
+        "opcode": "operator_letter_of",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "LETTER": [
+                1,
+                [
+                    6,
+                    "1"
+                ]
+            ],
+            "STRING": [
+                1,
+                [
+                    10,
+                    "apple"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 664,
+        "y": 445
+    },
+    "operator_length": {
+        "opcode": "operator_length",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "STRING": [
+                1,
+                [
+                    10,
+                    "apple"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 664,
+        "y": 521
+    },
+    "operator_contains": {
+        "opcode": "operator_contains",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "STRING1": [
+                1,
+                [
+                    10,
+                    "apple"
+                ]
+            ],
+            "STRING2": [
+                1,
+                [
+                    10,
+                    "a"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 634,
+        "y": 599
+    },
+    "operator_mod": {
+        "opcode": "operator_mod",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "NUM1": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ],
+            "NUM2": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 295,
+        "y": 594
+    },
+    "operator_round": {
+        "opcode": "operator_round",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "NUM": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 307,
+        "y": 674
+    },
+    "operator_mathop": {
+        "opcode": "operator_mathop",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "NUM": [
+                1,
+                [
+                    4,
+                    ""
+                ]
+            ]
+        },
+        "fields": {
+            "OPERATOR": [
+                "abs",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 280,
+        "y": 754
+    }
+}

blocks/classwise_blocks/sensing_block.json

@@ -0,0 +1,292 @@
+{
+    "sensing_touchingobject": {
+        "opcode": "sensing_touchingobject",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "TOUCHINGOBJECTMENU": [
+                1,
+                "sensing_touchingobjectmenu"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 359,
+        "y": 116
+    },
+    "sensing_touchingobjectmenu": {
+        "opcode": "sensing_touchingobjectmenu",
+        "next": null,
+        "parent": "sensing_touchingobject",
+        "inputs": {},
+        "fields": {
+            "TOUCHINGOBJECTMENU": [
+                "_mouse_",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "sensing_touchingcolor": {
+        "opcode": "sensing_touchingcolor",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "COLOR": [
+                1,
+                [
+                    9,
+                    "#55b888"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 360,
+        "y": 188
+    },
+    "sensing_coloristouchingcolor": {
+        "opcode": "sensing_coloristouchingcolor",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "COLOR": [
+                1,
+                [
+                    9,
+                    "#d019f2"
+                ]
+            ],
+            "COLOR2": [
+                1,
+                [
+                    9,
+                    "#2b0de3"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 348,
+        "y": 277
+    },
+    "sensing_askandwait": {
+        "opcode": "sensing_askandwait",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "QUESTION": [
+                1,
+                [
+                    10,
+                    "What's your name?"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 338,
+        "y": 354
+    },
+    "sensing_answer": {
+        "opcode": "sensing_answer",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 782,
+        "y": 111
+    },
+    "sensing_keypressed": {
+        "opcode": "sensing_keypressed",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "KEY_OPTION": [
+                1,
+                "sensing_keyoptions"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 762,
+        "y": 207
+    },
+    "sensing_keyoptions": {
+        "opcode": "sensing_keyoptions",
+        "next": null,
+        "parent": "sensing_keypressed",
+        "inputs": {},
+        "fields": {
+            "KEY_OPTION": [
+                "space",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "sensing_mousedown": {
+        "opcode": "sensing_mousedown",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 822,
+        "y": 422
+    },
+    "sensing_mousex": {
+        "opcode": "sensing_mousex",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 302,
+        "y": 528
+    },
+    "sensing_mousey": {
+        "opcode": "sensing_mousey",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 668,
+        "y": 547
+    },
+    "sensing_setdragmode": {
+        "opcode": "sensing_setdragmode",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "DRAG_MODE": [
+                "draggable",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 950,
+        "y": 574
+    },
+    "sensing_loudness": {
+        "opcode": "sensing_loudness",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 658,
+        "y": 703
+    },
+    "sensing_timer": {
+        "opcode": "sensing_timer",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 459,
+        "y": 671
+    },
+    "sensing_resettimer": {
+        "opcode": "sensing_resettimer",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 462,
+        "y": 781
+    },
+    "sensing_of": {
+        "opcode": "sensing_of",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "OBJECT": [
+                1,
+                "sensing_of_object_menu"
+            ]
+        },
+        "fields": {
+            "PROPERTY": [
+                "backdrop #",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 997,
+        "y": 754
+    },
+    "sensing_of_object_menu": {
+        "opcode": "sensing_of_object_menu",
+        "next": null,
+        "parent": "sensing_of",
+        "inputs": {},
+        "fields": {
+            "OBJECT": [
+                "_stage_",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "sensing_current": {
+        "opcode": "sensing_current",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {
+            "CURRENTMENU": [
+                "YEAR",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 627,
+        "y": 884
+    },
+    "sensing_dayssince2000": {
+        "opcode": "sensing_dayssince2000",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 959,
+        "y": 903
+    },
+    "sensing_username": {
+        "opcode": "sensing_username",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 833,
+        "y": 757
+    }
+}

blocks/classwise_blocks/sound_block.json

@@ -0,0 +1,167 @@
+{
+    "sound_playuntildone": {
+        "opcode": "sound_playuntildone",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "SOUND_MENU": [
+                1,
+                "sound_sounds_menu"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 253,
+        "y": 17
+    },
+    "sound_sounds_menu": {
+        "opcode": "sound_sounds_menu",
+        "next": null,
+        "parent": "sound_playuntildone and sound_play",
+        "inputs": {},
+        "fields": {
+            "SOUND_MENU": [
+                "Meow",
+                null
+            ]
+        },
+        "shadow": true,
+        "topLevel": false
+    },
+    "sound_play": {
+        "opcode": "sound_play",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "SOUND_MENU": [
+                1,
+                "sound_sounds_menu"
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 245,
+        "y": 122
+    },
+    "sound_stopallsounds": {
+        "opcode": "sound_stopallsounds",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 253,
+        "y": 245
+    },
+    "sound_changeeffectby": {
+        "opcode": "sound_changeeffectby",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "VALUE": [
+                1,
+                [
+                    4,
+                    "10"
+                ]
+            ]
+        },
+        "fields": {
+            "EFFECT": [
+                "PITCH",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 653,
+        "y": 14
+    },
+    "sound_seteffectto": {
+        "opcode": "sound_seteffectto",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "VALUE": [
+                1,
+                [
+                    4,
+                    "100"
+                ]
+            ]
+        },
+        "fields": {
+            "EFFECT": [
+                "PITCH",
+                null
+            ]
+        },
+        "shadow": false,
+        "topLevel": true,
+        "x": 653,
+        "y": 139
+    },
+    "sound_cleareffects": {
+        "opcode": "sound_cleareffects",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 651,
+        "y": 242
+    },
+    "sound_changevolumeby": {
+        "opcode": "sound_changevolumeby",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "VOLUME": [
+                1,
+                [
+                    4,
+                    "-10"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 645,
+        "y": 353
+    },
+    "sound_setvolumeto": {
+        "opcode": "sound_setvolumeto",
+        "next": null,
+        "parent": null,
+        "inputs": {
+            "VOLUME": [
+                1,
+                [
+                    4,
+                    "100"
+                ]
+            ]
+        },
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 1108,
+        "y": 5
+    },
+    "sound_volume": {
+        "opcode": "sound_volume",
+        "next": null,
+        "parent": null,
+        "inputs": {},
+        "fields": {},
+        "shadow": false,
+        "topLevel": true,
+        "x": 1136,
+        "y": 123
+    }
+}

blocks/hat_blocks.json

@@ -0,0 +1,217 @@
+{
+  "block_category": "Hat Blocks",
+  "description": "Hat blocks are characterized by a rounded top and a bump at the bottom. They initiate scripts, meaning they are the starting point for a sequence of interconnected blocks.",
+  "blocks": [
+    {
+      "block_name": "when green flag pressed",
+      "block_type": "Events",
+      "op_code": "event_whenflagclicked",
+      "block_shape": "Hat Block",
+      "functionality": "This Hat block initiates the script when the green flag is clicked, serving as the common starting point for most Scratch projects.",
+      "inputs": null,
+      "example_standalone": "when green flag clicked",
+      "example_with_other_blocks": [
+        {
+          "script": "when green flag clicked\n  go to x: (0) y: (0)\n  say [Hello!] for (2) seconds\nend",
+          "explanation": "This script makes the sprite go to the center of the stage and then say 'Hello!' for 2 seconds when the green flag is clicked."
+        }
+      ]
+    },
+    {
+      "block_name": "when () key pressed",
+      "block_type": "Events",
+      "op_code": "event_whenkeypressed",
+      "block_shape": "Hat Block",
+      "functionality": "This Hat block initiates the script when a specified keyboard key is pressed.",
+      "inputs": [
+        {
+          "name": "key",
+          "type": "dropdown",
+          "options": [
+            "space",
+            "up arrow",
+            "down arrow",
+            "right arrow",
+            "left arrow",
+            "any",
+            "a",
+            "b",
+            "c",
+            "d",
+            "e",
+            "f",
+            "g",
+            "h",
+            "i",
+            "j",
+            "k",
+            "l",
+            "m",
+            "n",
+            "o",
+            "p",
+            "q",
+            "r",
+            "s",
+            "t",
+            "u",
+            "v",
+            "w",
+            "x",
+            "y",
+            "z",
+            "0",
+            "1",
+            "2",
+            "3",
+            "4",
+            "5",
+            "6",
+            "7",
+            "8",
+            "9"
+          ]
+        }
+      ],
+      "example_standalone": "when [space v] key pressed",
+      "example_with_other_blocks": [
+        {
+          "script": "when [space v] key pressed\n  repeat (10)\n    change y by (10)\n    wait (0.1) seconds\n    change y by (-10)\n  end",
+          "explanation": "This script makes the sprite jump when the spacebar is pressed."
+        },
+        {
+          "script": "when [right arrow v] key pressed\n  point in direction (90)\n  move (10) steps\nend",
+          "explanation": "This script moves the sprite right when the right arrow key is pressed."
+        }
+      ]
+    },
+    {
+      "block_name": "when this sprite clicked",
+      "block_type": "Events",
+      "op_code": "event_whenthisspriteclicked",
+      "block_shape": "Hat Block",
+      "functionality": "This Hat block starts the script when the sprite itself is clicked.",
+      "inputs": null,
+      "example_standalone": "when this sprite clicked",
+      "example_with_other_blocks": [
+        {
+          "script": "when this sprite clicked\n  say [Ouch!] for (1) seconds\n  change [score v] by (-1)\nend",
+          "explanation": "This script makes the sprite say 'Ouch!' and decreases the score by 1 when the sprite is clicked."
+        }
+      ]
+    },
+    {
+      "block_name": "when backdrop switches to ()",
+      "block_type": "Events",
+      "op_code": "event_whenbackdropswitchesto",
+      "block_shape": "Hat Block",
+      "functionality": "This Hat block triggers the script when the stage backdrop changes to a specified backdrop.",
+      "inputs": [
+        {
+          "name": "backdrop name",
+          "type": "dropdown",
+          "options": ["backdrop1", "backdrop2", "..."]
+        }
+      ],
+      "example_standalone": "when backdrop switches to [game over v]",
+      "example_with_other_blocks": [
+        {
+          "script": "when backdrop switches to [game over v]\n  stop [all v]\nend",
+          "explanation": "This script stops all running processes when the backdrop changes to 'game over'."
+        },
+        {
+          "script": "when backdrop switches to [level completed v]\n  stop [all v]\nend",
+          "explanation": "This script stops all running processes when the backdrop changes to 'level completed'."
+        }
+      ]
+    },
+    {
+      "block_name": "when () > ()",
+      "block_type": "Events",
+      "op_code": "event_whengreaterthan",
+      "block_shape": "Hat Block",
+      "functionality": "This Hat block starts the script when a certain value (e.g., loudness from a microphone, or the timer) exceeds a defined threshold.",
+      "inputs": [
+        {
+          "name": "value type",
+          "type": "dropdown",
+          "options": [
+            "loudness",
+            "timer"
+          ]
+        },
+        {
+          "name": "threshold",
+          "type": "number"
+        }
+      ],
+      "example_standalone": "when [loudness v] > (70)",
+      "example_with_other_blocks": [
+        {
+          "script": "when [loudness v] > (70)\n  start sound [scream v]\nend",
+          "explanation": "This script starts a 'scream' sound when the microphone loudness exceeds 70."
+        }
+      ]
+    },
+    {
+      "block_name": "when I receive ()",
+      "block_type": "Events",
+      "op_code": "event_whenbroadcastreceived",
+      "block_shape": "Hat Block",
+      "functionality": "This Hat block initiates the script upon the reception of a specific broadcast message. This mechanism facilitates indirect communication between sprites or the stage.",
+      "inputs": [
+        {
+          "name": "message name",
+          "type": "dropdown",
+          "options": ["message1", "message2", "new message..."]
+        }
+      ],
+      "example_standalone": "when I receive [start game v]",
+      "example_with_other_blocks": [
+        {
+          "script": "when I receive [start game v]\n  show\n  go to x: (0) y: (0)\nend",
+          "explanation": "This script makes the sprite visible and moves it to the center of the stage when it receives the 'start game' broadcast."
+        },
+        {
+          "script": "when I receive [game over v]\n  set score to 0\n  stop [all v]\nend",
+          "explanation": "This script stops all and resets the score on stage when it receives the 'game over' broadcast."
+        }
+      ]
+    },
+    {
+      "block_name": "When I Start as a Clone",
+      "block_type": "Control",
+      "op_code": "control_start_as_clone",
+      "block_shape": "Hat Block",
+      "functionality": "This Hat block initiates the script when a clone of the sprite is created. It defines the behavior of individual clones.",
+      "inputs": null,
+      "example_standalone": "When I Start as a Clone",
+      "example_with_other_blocks": [
+        {
+          "script": "when I start as a clone\n  go to x: (pick random -240 to 240) y: (pick random -180 to 180)\n  show\n  forever\n    move (10) steps\n    if on edge, bounce\n  end\nend",
+          "explanation": "This script makes a newly created clone appear at a random position, become visible, and then continuously move 10 steps, bouncing if it hits an edge."
+        }
+      ]
+    },
+    {
+      "block_name": "define [my custom block]",
+      "block_type": "My Blocks",
+      "op_code": "procedures_definition",
+      "block_shape": "Hat Block",
+      "functionality": "This Hat block serves as the definition header for a custom block's script. It allows users to define reusable sequences of code by specifying the block's name and any input parameters it will accept. This promotes modularity and abstraction in projects.",
+      "inputs": [
+        {
+          "name": "PROCCONTAINER",
+          "type": "block_prototype"
+        }
+      ],
+      "example_standalone": "define jump (height)",
+      "example_with_other_blocks": [
+        {
+          "script": "define jump (height)\n  change y by (height)\n  wait (0.5) seconds\n  change y by (0 - (height))\nend\n\nwhen green flag clicked\n  jump (50)\nend",
+          "explanation": "This script first defines a custom block named 'jump' that takes a numerical input 'height'. The definition outlines the actions for jumping up and then down. Later, 'jump (50)' is called to make the sprite jump 50 units."
+        }
+      ]
+    }
+  ]
+}

blocks/reporter_blocks.json

@@ -0,0 +1,709 @@
+{
+  "block_category": "Reporter Blocks",
+  "description": "Reporter blocks have rounded edges. Their purpose is to report values, which can be numbers or strings, and are designed to fit into input slots of other blocks.",
+  "blocks": [
+    {
+      "block_name": "(x position)",
+      "block_type": "Motion",
+      "op_code": "motion_xposition",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the current X-coordinate of the sprite.[NOTE: not used in stage/backdrops]",
+      "inputs": null,
+      "example_standalone": "x position",
+      "example_with_other_blocks": [
+        {
+          "script": "when green flag clicked\n  say (x position) for (2) seconds\nend",
+          "explanation": "This script makes the sprite say its current X-coordinate for 2 seconds."
+        }
+      ]
+    },
+    {
+      "block_name": "(y position)",
+      "block_type": "Motion",
+      "op_code": "motion_yposition",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the current Y coordinate of the sprite on the stage.[NOTE: not used in stage/backdrops]",
+      "inputs": null,
+      "example_standalone": "y position",
+      "example_with_other_blocks": [
+        {
+          "script": "set [worms v] to (y position)",
+          "explanation": "This script assigns the sprite's current Y position to the 'worms' variable."
+        }
+      ]
+    },
+    {
+      "block_name": "(direction)",
+      "block_type": "Motion",
+      "op_code": "motion_direction",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the current direction of the sprite in degrees (0 = up, 90 = right, 180 = down, -90 = left).[NOTE: not used in stage/backdrops]",
+      "inputs": null,
+      "example_standalone": "direction",
+      "example_with_other_blocks": [
+        {
+          "script": "when green flag clicked\n  say (direction) for (2) seconds\nend",
+          "explanation": "This script makes the sprite say its current direction in degrees for 2 seconds."
+        }
+      ]
+    },
+    {
+      "block_name": "(costume ())",
+      "block_type": "Looks",
+      "op_code": "looks_costumenumbername",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the current costume's number or name.",
+      "inputs": [
+        {
+          "name": "NUMBER_NAME",
+          "type": "dropdown",
+          "options": [
+            "number",
+            "name"
+          ]
+        }
+      ],
+      "example_standalone": "costume [number v]",
+      "example_with_other_blocks": [
+        {
+          "script": "say join [I am costume ] (costume [name v])",
+          "explanation": "This script makes the sprite display its current costume name in a speech bubble."
+        }
+      ]
+    },
+    {
+      "block_name": "(size)",
+      "block_type": "Looks",
+      "op_code": "looks_size",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the current size of the sprite as a percentage.",
+      "inputs": null,
+      "example_standalone": "size",
+      "example_with_other_blocks": [
+        {
+          "script": "set size to ( (size) + (10) )",
+          "explanation": "This script increases the sprite's size by 10% from its current size."
+        }
+      ]
+    },
+    {
+      "block_name": "(backdrop ())",
+      "block_type": "Looks",
+      "op_code": "looks_backdropnumbername",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the current backdrop's number or name.",
+      "inputs": [
+        {
+          "name": "NUMBER_NAME",
+          "type": "dropdown",
+          "options": [
+            "number",
+            "name"
+          ]
+        }
+      ],
+      "example_standalone": "(backdrop [number v])",
+      "example_with_other_blocks": [
+        {
+          "script": "say join [Current backdrop: ] (backdrop [name v]) for (2) seconds",
+          "explanation": "This script makes the sprite say the name of the current stage backdrop for 2 seconds."
+        }
+      ]
+    },
+    {
+      "block_name": "(volume)",
+      "block_type": "Sound",
+      "op_code": "sound_volume",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the current volume level of the sprite.",
+      "inputs": null,
+      "example_standalone": "volume",
+      "example_with_other_blocks": [
+        {
+          "script": "say join [Current volume: ] (volume)",
+          "explanation": "This script makes the sprite display its current volume level in a speech bubble."
+        }
+      ]
+    },
+    {
+      "block_name": "(distance to ())",
+      "block_type": "Sensing",
+      "op_code": "sensing_distanceto",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the distance from the current sprite to the mouse-pointer or another specified sprite.",
+      "inputs": [
+        {
+          "name": "target",
+          "type": "dropdown",
+          "options": ["mouse-pointer", "Sprite1", "Sprite2", "...", "_edge_"]
+        }
+      ],
+      "example_standalone": "distance to [mouse-pointer v]",
+      "example_with_other_blocks": [
+        {
+          "script": "if <(distance to [Sprite2 v]) < (50)> then\n  say [Too close!]\nend",
+          "explanation": "This script makes the sprite say 'Too close!' if it is less than 50 steps away from 'Sprite2'."
+        }
+      ]
+    },
+    {
+      "block_name": "(answer)",
+      "block_type": "Sensing",
+      "op_code": "sensing_answer",
+      "block_shape": "Reporter Block",
+      "functionality": "Holds the most recent text inputted using the 'Ask () and Wait' block.",
+      "inputs": null,
+      "example_standalone": "answer",
+      "example_with_other_blocks": [
+        {
+          "script": "ask [What is your name?] and wait\n  say join [Hello ] (answer)",
+          "explanation": "This script prompts the user for their name and then uses the 'answer' block to incorporate their input into a greeting."
+        }
+      ]
+    },
+    {
+      "block_name": "(mouse x)",
+      "block_type": "Sensing",
+      "op_code": "sensing_mousex",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the mouse-pointer’s current X position on the stage.",
+      "inputs": null,
+      "example_standalone": "mouse x",
+      "example_with_other_blocks": [
+        {
+          "script": "go to x: (mouse x) y: (mouse y)",
+          "explanation": "This script makes the sprite follow the mouse pointer's X and Y coordinates."
+        }
+      ]
+    },
+    {
+      "block_name": "(mouse y)",
+      "block_type": "Sensing",
+      "op_code": "sensing_mousey",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the mouse-pointer’s current Y position on the stage.",
+      "inputs": null,
+      "example_standalone": "mouse y",
+      "example_with_other_blocks": [
+        {
+          "script": "if <(mouse y) < (0)> then\n  say [Below center]",
+          "explanation": "This script makes the sprite say 'Below center' if the mouse pointer is in the lower half of the stage."
+        }
+      ]
+    },
+    {
+      "block_name": "(loudness)",
+      "block_type": "Sensing",
+      "op_code": "sensing_loudness",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the loudness of noise received by a microphone on a scale of 0 to 100.",
+      "inputs": null,
+      "example_standalone": "loudness",
+      "example_with_other_blocks": [
+        {
+          "script": "when green flag clicked\n  forever\n    if <(loudness) > (30)> then\n      start sound [pop v]\nend",
+          "explanation": "This script continuously checks the microphone loudness and plays a 'pop' sound if it exceeds 30."
+        }
+      ]
+    },
+    {
+      "block_name": "(timer)",
+      "block_type": "Sensing",
+      "op_code": "sensing_timer",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the elapsed time since Scratch was launched or the timer was reset, increasing by 1 every second.",
+      "inputs": null,
+      "example_standalone": "timer",
+      "example_with_other_blocks": [
+        {
+          "script": "when green flag clicked\n  reset timer\n  wait (5) seconds\n  say join [Time elapsed: ] (timer)",
+          "explanation": "This script resets the timer when the green flag is clicked, waits for 5 seconds, and then reports the elapsed time."
+        }
+      ]
+    },
+    {
+      "block_name": "(() of ())",
+      "block_type": "Sensing",
+      "op_code": "sensing_of",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports a specified value (e.g., x position, direction, costume number) of a specified sprite or the Stage to be accessed in current sprite or stage.",
+      "inputs": [
+        {
+          "name": "value to report",
+          "type": "dropdown",
+          "options": [
+            "x position",
+            "y position",
+            "direction",
+            "costume #",
+            "costume name",
+            "size",
+            "volume",
+            "backdrop #",
+            "backdrop name"
+          ]
+        },
+        {
+          "name": "sprite/stage",
+          "type": "dropdown",
+          "options": ["Stage", "Sprite1", "Sprite2", "...", "_edge_"]
+        }
+      ],
+      "example_standalone": "x position of [Sprite1 v]",
+      "example_with_other_blocks": [
+        {
+          "script": "set [other sprite X v] to ( (x position) of [Sprite2 v] )",
+          "explanation": "This script sets the 'other sprite X' variable to the current X-position of 'Sprite2'."
+        }
+      ]
+    },
+    {
+      "block_name": "(current ())",
+      "block_type": "Sensing",
+      "op_code": "sensing_current",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the current local year, month, date, day of the week, hour, minutes, or seconds.",
+      "inputs": [
+        {
+          "name": "time unit",
+          "type": "dropdown",
+          "options": [
+            "year",
+            "month",
+            "date",
+            "day of week",
+            "hour",
+            "minute",
+            "second"
+          ]
+        }
+      ],
+      "example_standalone": "current [hour v]",
+      "example_with_other_blocks": [
+        {
+          "script": "say join [The current hour is ] (current [hour v])",
+          "explanation": "This script makes the sprite say the current hour."
+        }
+      ]
+    },
+    {
+      "block_name": "(days since 2000)",
+      "block_type": "Sensing",
+      "op_code": "sensing_dayssince2000",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the number of days (and fractions of a day) since 00:00:00 UTC on January 1, 2000.",
+      "inputs": null,
+      "example_standalone": "days since 2000",
+      "example_with_other_blocks": [
+        {
+          "script": "say join [Days passed: ] (days since 2000)",
+          "explanation": "This script makes the sprite display the number of days that have passed since January 1, 2000."
+        }
+      ]
+    },
+    {
+      "block_name": "(username)",
+      "block_type": "Sensing",
+      "op_code": "sensing_username",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the username of the user currently logged into Scratch. If no user is logged in, it reports nothing.",
+      "inputs": null,
+      "example_standalone": "username",
+      "example_with_other_blocks": [
+        {
+          "script": "say join [Hello, ] (username)",
+          "explanation": "This script makes the sprite greet the user by their Scratch username."
+        }
+      ]
+    },
+    {
+      "block_name": "(() + ())",
+      "block_type": "operator",
+      "op_code": "operator_add",
+      "block_shape": "Reporter Block",
+      "functionality": "Adds two numerical values.",
+      "inputs": [
+        {
+          "name": "number1",
+          "type": "number"
+        },
+        {
+          "name": "number2",
+          "type": "number"
+        }
+      ],
+      "example_standalone": "(5) + (3)",
+      "example_with_other_blocks": [
+        {
+          "script": "set [total v] to ( (number 1) + (number 2) )",
+          "explanation": "This script calculates the sum of 'number 1' and 'number 2' and stores the result in the 'total' variable."
+        }
+      ]
+    },
+    {
+      "block_name": "(() - ())",
+      "block_type": "operator",
+      "op_code": "operator_subtract",
+      "block_shape": "Reporter Block",
+      "functionality": "Subtracts the second numerical value from the first.",
+      "inputs": [
+        {
+          "name": "number1",
+          "type": "number"
+        },
+        {
+          "name": "number2",
+          "type": "number"
+        }
+      ],
+      "example_standalone": "((10) - (4))",
+      "example_with_other_blocks": [
+        {
+          "script": "set [difference v] to ( (number 1) - (number 2) )",
+          "explanation": "This script calculates the subtraction of 'number 2' from 'number 1' and stores the result in the 'difference' variable."
+        }
+      ]
+    },
+    {
+      "block_name": "(() * ())",
+      "block_type": "operator",
+      "op_code": "operator_multiply",
+      "block_shape": "Reporter Block",
+      "functionality": "Multiplies two numerical values.",
+      "inputs": [
+        {
+          "name": "number1",
+          "type": "number"
+        },
+        {
+          "name": "number2",
+          "type": "number"
+        }
+      ],
+      "example_standalone": "(6) * (7)",
+      "example_with_other_blocks": [
+        {
+          "script": "set [area v] to ( (length) * (width) )",
+          "explanation": "This script calculates the area by multiplying 'length' and 'width' variables and stores it in the 'area' variable."
+        }
+      ]
+    },
+    {
+      "block_name": "(() / ())",
+      "block_type": "operator",
+      "op_code": "operator_divide",
+      "block_shape": "Reporter Block",
+      "functionality": "Divides the first numerical value by the second.",
+      "inputs": [
+        {
+          "name": "number1",
+          "type": "number"
+        },
+        {
+          "name": "number2",
+          "type": "number"
+        }
+      ],
+      "example_standalone": "((20) / (5))",
+      "example_with_other_blocks": [
+        {
+          "script": "set [average v] to ( (total score) / (number of students) )",
+          "explanation": "This script calculates the average by dividing 'total score' by 'number of students' and stores it in the 'average' variable."
+        }
+      ]
+    },
+    {
+      "block_name": "(pick random () to ())",
+      "block_type": "operator",
+      "op_code": "operator_random",
+      "block_shape": "Reporter Block",
+      "functionality": "Generates a random integer within a specified inclusive range.",
+      "inputs": [
+        {
+          "name": "min",
+          "type": "number"
+        },
+        {
+          "name": "max",
+          "type": "number"
+        }
+      ],
+      "example_standalone": "(pick random (1) to (10))",
+      "example_with_other_blocks": [
+        {
+          "script": "go to x: (pick random -240 to 240) y: (pick random -180 to 180)",
+          "explanation": "This script moves the sprite to a random position on the stage."
+        }
+      ]
+    },
+    {
+      "block_name": "(join ()())",
+      "block_type": "operator",
+      "op_code": "operator_join",
+      "block_shape": "Reporter Block",
+      "functionality": "Concatenates two strings or values into a single string.",
+      "inputs": [
+        {
+          "name": "string1",
+          "type": "string/number"
+        },
+        {
+          "name": "string2",
+          "type": "string/number"
+        }
+      ],
+      "example_standalone": "(join [Hello ][World!])",
+      "example_with_other_blocks": [
+        {
+          "script": "say (join [Hello ][World!])",
+          "explanation": "This script makes the sprite display 'Hello World!' in a speech bubble by joining two string literals."
+        }
+      ]
+    },
+    {
+      "block_name": "letter () of ()",
+      "block_type": "operator",
+      "op_code": "operator_letterof",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the character at a specific numerical position within a string.",
+      "inputs": [
+        {
+          "name": "index",
+          "type": "number"
+        },
+        {
+          "name": "text",
+          "type": "string"
+        }
+      ],
+      "example_standalone": "(letter (1) of [apple])",
+      "example_with_other_blocks": [
+        {
+          "script": "say (letter (1) of [apple])",
+          "explanation": "This script makes the sprite display the first character of the string 'apple', which is 'a'."
+        }
+      ]
+    },
+    {
+      "block_name": "(length of ())",
+      "block_type": "operator",
+      "op_code": "operator_length",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the total number of characters in a given string.",
+      "inputs": [
+        {
+          "name": "text",
+          "type": "string"
+        }
+      ],
+      "example_standalone": "(length of [banana])",
+      "example_with_other_blocks": [
+        {
+          "script": "say (length of [banana])",
+          "explanation": "This script makes the sprite display the length of the string 'banana', which is 6."
+        }
+      ]
+    },
+    {
+      "block_name": "(() mod ())",
+      "block_type": "operator",
+      "op_code": "operator_mod",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the remainder when the first number is divided by the second.",
+      "inputs": [
+        {
+          "name": "number1",
+          "type": "number"
+        },
+        {
+          "name": "number2",
+          "type": "number"
+        }
+      ],
+      "example_standalone": "((10) mod (3))",
+      "example_with_other_blocks": [
+        {
+          "script": "if <([number v] mod (2) = (0))> then\n  say [Even number]",
+          "explanation": "This script checks if a 'number' variable is even by checking if its remainder when divided by 2 is 0."
+        }
+      ]
+    },
+    {
+      "block_name": "(round ())",
+      "block_type": "operator",
+      "op_code": "operator_round",
+      "block_shape": "Reporter Block",
+      "functionality": "Rounds a numerical value to the nearest integer.",
+      "inputs": [
+        {
+          "name": "number",
+          "type": "number"
+        }
+      ],
+      "example_standalone": "(round (3.7))",
+      "example_with_other_blocks": [
+        {
+          "script": "set [rounded score v] to (round (score))",
+          "explanation": "This script rounds the 'score' variable to the nearest whole number and stores it in 'rounded score'."
+        }
+      ]
+    },
+    {
+      "block_name": "(() of ())",
+      "block_type": "operator",
+      "op_code": "operator_mathop",
+      "block_shape": "Reporter Block",
+      "functionality": "Performs various mathematical functions (e.g., absolute value, square root, trigonometric functions).",
+      "inputs": [
+        {
+          "name": "function type",
+          "type": "dropdown",
+          "options": [
+            "abs",
+            "floor",
+            "ceiling",
+            "sqrt",
+            "sin",
+            "cos",
+            "tan",
+            "asin",
+            "acos",
+            "atan",
+            "ln",
+            "log",
+            "e ^",
+            "10 ^"
+          ]
+        },
+        {
+          "name": "value",
+          "type": "number"
+        }
+      ],
+      "example_standalone": "([sqrt v] of (25))",
+      "example_with_other_blocks": [
+        {
+          "script": "set [distance v] to ([sqrt v] of ( ( (x position) * (x position) ) + ( (y position) * (y position) ) ))",
+          "explanation": "This script calculates the distance from the origin (0,0) using the Pythagorean theorem and stores it in 'distance'."
+        }
+      ]
+    },
+    {
+      "block_name": "[variable v]",
+      "block_type": "Data",
+      "op_code": "data_variable",
+      "block_shape": "Reporter Block",
+      "functionality": "Provides the current value stored in a variable.",
+      "inputs": [
+        {
+          "name": "variable name",
+          "type": "dropdown",
+          "options": ["my variable", "score", "..."]
+        }
+      ],
+      "example_standalone": "[score v]",
+      "example_with_other_blocks": [
+        {
+          "script": "say ([score v]) for (2) seconds",
+          "explanation": "This script makes the sprite say the current value of the 'score' variable for 2 seconds."
+        }
+      ]
+    },
+    {
+      "block_name": "[list v]",
+      "block_type": "Data",
+      "op_code": "data_list",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the entire content of a specified list. When clicked in the editor, it displays the list as a monitor.",
+      "inputs": [
+        {
+          "name": "list name",
+          "type": "dropdown",
+          "options": ["my list", "list2", "..."]
+        }
+      ],
+      "example_standalone": "[my list v]",
+      "example_with_other_blocks": [
+        {
+          "script": "say ([my list v]) ",
+          "explanation": "This script makes the sprite say all the contents of 'my list'."
+        }
+      ]
+    },
+    {
+      "block_name": "(item (2) of [myList v])",
+      "block_type": "Data",
+      "op_code": "data_itemoflist",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the item located at a specific position in a list.",
+      "inputs": [
+        {
+          "name": "index/option",
+          "type": "number or dropdown",
+          "options": [
+            "last",
+            "random"
+          ]
+        },
+        {
+          "name": "list name",
+          "type": "dropdown",
+          "options": ["shopping list", "my list", "..."]
+        }
+      ],
+      "example_standalone": "item (1) of [shopping list v]",
+      "example_with_other_blocks": [
+        {
+          "script": "say (item (2) of [myList v]) for 2 seconds ",
+          "explanation": "This script makes the sprite display the first item from the 'shopping list'."
+        }
+      ]
+    },
+    {
+      "block_name": "(length of [myList v])",
+      "block_type": "Data",
+      "op_code": "data_lengthoflist",
+      "block_shape": "Reporter Block",
+      "functionality": "Provides the total number of items contained in a list.",
+      "inputs": [
+        {
+          "name": "list name",
+          "type": "dropdown",
+          "options": ["my list", "shopping list", "..."]
+        }
+      ],
+      "example_standalone": "(length of [myList v])",
+      "example_with_other_blocks": [
+        {
+          "script": "say join (length of [shopping list v]) [ items in the list.]",
+          "explanation": "This script makes the sprite display the total number of items currently in the 'shopping list'."
+        }
+      ]
+    },
+    {
+      "block_name": "(item # of [Dog] in [myList v])",
+      "block_type": "Data",
+      "op_code": "data_itemnumoflist",
+      "block_shape": "Reporter Block",
+      "functionality": "Reports the index number of the first occurrence of a specified item in a list. If the item is not found, it reports 0.",
+      "inputs": [
+        {
+          "name": "item",
+          "type": "string/number"
+        },
+        {
+          "name": "list name",
+          "type": "dropdown",
+          "options": ["my list", "shopping list", "..."]
+        }
+      ],
+      "example_standalone": "(item # of [apple] in [shopping list v])",
+      "example_with_other_blocks": [
+        {
+          "script": "if <(item # of [Dog] in [myList v])> (0)> then\n  say join [Dog found at position ] (item # of [Dog] in [my list v])",
+          "explanation": "This script checks if 'banana' is in 'my list' and, if so, reports its position."
+        }
+      ]
+    }
+  ]
+}

blocks/stack_blocks.json

@@ -0,0 +1,1321 @@
+{
+    "block_category": "Stack Blocks",
+    "description": "Stack blocks are the most common block shape, featuring a notch at the top and a bump at the bottom. They perform the main commands within a script and can connect both above and below them.",
+    "blocks": [
+        {
+            "block_name": "move () steps",
+            "block_type": "Motion",
+            "block_shape": "Stack Block",
+            "op_code": "motion_movesteps",
+            "functionality": "Moves the sprite forward by the specified number of steps in the direction it is currently facing. A positive value moves it forward, and a negative value moves it backward.",
+            "inputs": [
+                {
+                    "name": "STEPS",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "move () steps",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n  go to x: (0) y: (0)\n  point in direction (90)\n  move (50) steps\nend",
+                    "explanation": "This script first places the sprite at the center of the stage, points it to the right (90 degrees), and then moves it 50 steps in that direction."
+                }
+            ]
+        },
+        {
+            "block_name": "turn right () degrees",
+            "block_type": "Motion",
+            "block_shape": "Stack Block",
+            "op_code": "motion_turnright",
+            "functionality": "Turns the sprite clockwise by the specified number of degrees.",
+            "inputs": [
+                {
+                    "name": "DEGREES",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "turn (clockwise icon) (15) degrees",
+            "example_with_other_blocks": [
+                {
+                    "script": "when [right arrow v] key pressed\n  turn (clockwise icon) (15) degrees\nend",
+                    "explanation": "This script makes the sprite turn clockwise by 15 degrees every time the right arrow key is pressed."
+                },
+                {
+                    "script": "when green flag clicked\n  forever\n    turn (clockwise icon) (15) degrees\n    wait (0.5) seconds\n  end",
+                    "explanation": "This script makes the sprite continuously spin clockwise by 15 degrees every half second."
+                }
+            ]
+        },
+        {
+            "block_name": "turn left () degrees",
+            "block_type": "Motion",
+            "block_shape": "Stack Block",
+            "op_code": "motion_turnleft",
+            "functionality": "Turns the sprite counter-clockwise by the specified number of degrees.",
+            "inputs": [
+                {
+                    "name": "DEGREES",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "turn (counter-clockwise icon) (15) degrees",
+            "example_with_other_blocks": [
+                {
+                    "script": "when [left arrow v] key pressed\n  turn (counter-clockwise icon) (15) degrees\nend",
+                    "explanation": "This script makes the sprite turn counter-clockwise by 15 degrees every time the left arrow key is pressed."
+                },
+                {
+                    "script": "when green flag clicked\n  forever\n    turn (counter-clockwise icon) (15) degrees\n    wait (0.5) seconds\n  end\nend",
+                    "explanation": "This script makes the sprite continuously spin counter-clockwise by 15 degrees every half second."
+                }
+            ]
+        },
+        {
+            "block_name": "go to ()",
+            "block_type": "Motion",
+            "block_shape": "Stack Block",
+            "op_code": "motion_goto",
+            "functionality": "Moves the sprite to a specified location, which can be a random position or at the mouse pointer or another to the sprite.",
+            "inputs": [
+                {
+                    "name": "TO",
+                    "type": "dropdown",
+                    "options": [
+                        "random position",
+                        "mouse-pointer",
+                        "sprite1",
+                        "..."
+                    ]
+                }
+            ],
+            "example_standalone": "go to [random position v]",
+            "example_with_other_blocks": [
+                {
+                    "script": "when this sprite clicked\n  go to [mouse-pointer v]",
+                    "explanation": "This script moves the sprite to the current position of the mouse pointer whenever the sprite is clicked."
+                },
+                {
+                    "script": "when this sprite clicked\n  go to [sprite v]",
+                    "explanation": "This script moves the sprite to the another sprite's position whenever the sprite is clicked."
+                }
+            ]
+        },
+        {
+            "block_name": "go to x: () y: ()",
+            "block_type": "Motion",
+            "block_shape": "Stack Block",
+            "op_code": "motion_gotoxy",
+            "functionality": "Moves the sprite to the specified X and Y coordinates on the stage.",
+            "inputs": [
+                {
+                    "name": "X",
+                    "type": "number"
+                },
+                {
+                    "name": "Y",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "go to x: (0) y: (0)",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n  go to x: (120) y: (0)\n  say [Ready to start! v] for (1) seconds\nend",
+                    "explanation": "This script positions the sprite at the center of the stage at the beginning of the project and then makes it say 'Ready to start!'."
+                }
+            ]
+        },
+        {
+            "block_name": "glide () secs to ()",
+            "block_type": "Motion",
+            "block_shape": "Stack Block",
+            "op_code": "motion_glideto",
+            "functionality": "Glides the sprite smoothly to a specified location (random position, mouse pointer, or another sprite) over a given number of seconds.",
+            "inputs": [
+                {
+                    "name": "SECS",
+                    "type": "number"
+                },
+                {
+                    "name": "TO",
+                    "type": "dropdown",
+                    "options": [
+                        "random position",
+                        "mouse-pointer",
+                        "sprite1",
+                        "sprite2",
+                        "..."
+                    ]
+                }
+            ],
+            "example_standalone": "glide (1) secs to ([random position v])",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n  glide (1) secs to ([mouse-pointer v])\nend",
+                    "explanation": "This script makes the sprite glide smoothly to the mouse pointer's position over 1 second when the green flag is clicked."
+                }
+            ]
+        },
+        {
+            "block_name": "glide () secs to x: () y: ()",
+            "block_type": "Motion",
+            "block_shape": "Stack Block",
+            "op_code": "motion_glidesecstoxy",
+            "functionality": "Glides the sprite smoothly to the specified X and Y coordinates over a given number of seconds.",
+            "inputs": [
+                {
+                    "name": "SECS",
+                    "type": "number"
+                },
+                {
+                    "name": "X",
+                    "type": "number"
+                },
+                {
+                    "name": "Y",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "glide (1) secs to x: (100) y: (50)",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n  glide (2) secs to x: (150) y: (-100)\n  glide (2) secs to x: (-150) y: (100)\nend",
+                    "explanation": "This script makes the sprite glide to two different points on the stage, taking 2 seconds for each movement."
+                }
+            ]
+        },
+        {
+            "block_name": "point in direction ()",
+            "block_type": "Motion",
+            "block_shape": "Stack Block",
+            "op_code": "motion_pointindirection",
+            "functionality": "Sets the sprite's direction to a specified angle in degrees (0 = up, 90 = right, 180 = down, -90 = left).",
+            "inputs": [
+                {
+                    "name": "DIRECTION",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "point in direction (90)",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n  point in direction (0)\n  move (100) steps\nend",
+                    "explanation": "This script makes the sprite point upwards (0 degrees) and then move 100 steps in that direction."
+                }
+            ]
+        },
+        {
+            "block_name": "point towards ()",
+            "block_type": "Motion",
+            "block_shape": "Stack Block",
+            "op_code": "motion_pointtowards",
+            "functionality": "Points the sprite towards the mouse pointer or another specified sprite.",
+            "inputs": [
+                {
+                    "name": "TOWARDS",
+                    "type": "dropdown",
+                    "options": [
+                        "mouse-pointer",
+                        "sprite1",
+                        "..."
+                    ]
+                }
+            ],
+            "example_standalone": "point towards [mouse-pointer v]",
+            "example_with_other_blocks": [
+                {
+                    "script": "when this sprite clicked\n  point towards [mouse-pointer v]\n  move (10) steps\nend",
+                    "explanation": "When the sprite is clicked, it will point towards the mouse pointer and then move 10 steps in that direction."
+                },
+                {
+                    "script": "when green flag clicked\n  forever\n    point towards [mouse-pointer v]\n    move (5) steps\n  end\nend",
+                    "explanation": "This script makes the sprite continuously follow the mouse pointer."
+                }
+            ]
+        },
+        {
+            "block_name": "change x by ()",
+            "block_type": "Motion",
+            "block_shape": "Stack Block",
+            "op_code": "motion_changexby",
+            "functionality": "Changes the sprite's X-coordinate by the specified amount, moving it horizontally.",
+            "inputs": [
+                {
+                    "name": "DX",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "change x by (10)",
+            "example_with_other_blocks": [
+                {
+                    "script": "when [right arrow v] key pressed\n  change x by (10)\nend",
+                    "explanation": "This script moves the sprite 10 steps to the right when the right arrow key is pressed."
+                }
+            ]
+        },
+        {
+            "block_name": "set x to ()",
+            "block_type": "Motion",
+            "block_shape": "Stack Block",
+            "op_code": "motion_setx",
+            "functionality": "Sets the sprite's X-coordinate to a specific value, placing it at a precise horizontal position.",
+            "inputs": [
+                {
+                    "name": "X",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "set x to (0)",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n  set x to (0)\n  set y to (0)\nend",
+                    "explanation": "This script centers the sprite horizontally at the start of the project."
+                }
+            ]
+        },
+        {
+            "block_name": "change y by ()",
+            "block_type": "Motion",
+            "block_shape": "Stack Block",
+            "op_code": "motion_changeyby",
+            "functionality": "Changes the sprite's Y-coordinate by the specified amount, moving it vertically.",
+            "inputs": [
+                {
+                    "name": "DY",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "change y by (10)",
+            "example_with_other_blocks": [
+                {
+                    "script": "when [up arrow v] key pressed\n  change y by (10)\nend",
+                    "explanation": "This script moves the sprite 10 steps up when the up arrow key is pressed."
+                }
+            ]
+        },
+        {
+            "block_name": "set y to ()",
+            "block_type": "Motion",
+            "block_shape": "Stack Block",
+            "op_code": "motion_sety",
+            "functionality": "Sets the sprite's Y-coordinate to a specific value, placing it at a precise vertical position.",
+            "inputs": [
+                {
+                    "name": "Y",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "set y to (0)",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n  set x to (0)\n  set y to (0)\nend",
+                    "explanation": "This script centers the sprite vertically at the start of the project."
+                }
+            ]
+        },
+        {
+            "block_name": "if on edge, bounce",
+            "block_type": "Motion",
+            "block_shape": "Stack Block",
+            "op_code": "motion_ifonedgebounce",
+            "functionality": "Reverses the sprite's direction if it touches the edge of the stage.",
+            "inputs": null,
+            "example_standalone": "if on edge, bounce",
+            "example_with_other_blocks": [
+                {
+                    "script": "when I receive [start moving v]\n  repeat (50)\n    move (5) steps\n    if on edge, bounce\n  end\nend",
+                    "explanation": "Upon receiving the 'start moving' broadcast, the sprite will move 5 steps repeatedly for 50 times, bouncing off edges if it touches them."
+                },
+                {
+                    "script": "when green flag clicked\n  forever\n    move (10) steps\n    if on edge, bounce\n  end\nend",
+                    "explanation": "This script makes the sprite move continuously and bounce off the edges of the stage."
+                }
+            ]
+        },
+        {
+            "block_name": "set rotation style ()",
+            "block_type": "Motion",
+            "block_shape": "Stack Block",
+            "op_code": "motion_setrotationstyle",
+            "functionality": "Determines how the sprite rotates: 'left-right' (flips horizontally), 'don't rotate' (stays facing one direction), or 'all around' (rotates freely).",
+            "inputs": [
+                {
+                    "name": "STYLE",
+                    "type": "dropdown",
+                    "options": [
+                        "left-right",
+                        "don't rotate",
+                        "all around"
+                    ]
+                }
+            ],
+            "example_standalone": "set rotation style [left-right v]",
+            "example_with_other_blocks": [
+                {
+                    "script": "when backdrop switches to [game level 1 v]\n  set rotation style [all around v]\nend",
+                    "explanation": "When the backdrop changes to 'game level 1', the sprite's rotation style will be set to 'all around', allowing it to rotate freely."
+                },
+                {
+                    "script": "when green flag clicked\n  set rotation style [left-right v]\n  forever\n    move (10) steps\n    if on edge, bounce\n  end \nend",
+                    "explanation": "This script makes the sprite move horizontally and flip its costume when it hits an edge, instead of rotating."
+                }
+            ]
+        },
+        {
+            "block_name": "say () for () seconds",
+            "block_type": "Looks",
+            "block_shape": "Stack Block",
+            "op_code": "looks_sayforsecs",
+            "functionality": "Displays a speech bubble containing specified text for a set duration.",
+            "inputs": [
+                {
+                    "name": "MESSAGE",
+                    "type": "string"
+                },
+                {
+                    "name": "SECS",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "say [Hello!] for (2) seconds",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n   say [Grr] for (3) seconds\n   say [Have you seen my honey? v] for (3) seconds\nend",
+                    "explanation": "This script makes the sprite display two sequential speech bubbles with different messages and durations. First, it says 'Grr' for 3 seconds, then 'Have you seen my honey?' for another 3 seconds."
+                }
+            ]
+        },
+        {
+            "block_name": "say ()",
+            "block_type": "Looks",
+            "block_shape": "Stack Block",
+            "op_code": "looks_say",
+            "functionality": "Displays a speech bubble with the specified text indefinitely until another 'say' or 'think' block is activated.",
+            "inputs": [
+                {
+                    "name": "MESSAGE",
+                    "type": "string"
+                }
+            ],
+            "example_standalone": "say [Hello! v]",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n   say [Welcome to my game! v]\n   wait (2) seconds\n   say [] \nend",
+                    "explanation": "This script makes the sprite say 'Welcome to my game!' for 2 seconds, then clears the speech bubble."
+                }
+            ]
+        },
+        {
+            "block_name": "think () for () seconds",
+            "block_type": "Looks",
+            "block_shape": "Stack Block",
+            "op_code": "looks_thinkforsecs",
+            "functionality": "Displays a thought bubble containing specified text for a set duration.",
+            "inputs": [
+                {
+                    "name": "MESSAGE",
+                    "type": "string"
+                },
+                {
+                    "name": "SECS",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "think [Hmm... v] for (2) seconds",
+            "example_with_other_blocks": [
+                {
+                    "script": "when this sprite clicked\n   think [What should I do? v] for (2) seconds\nend",
+                    "explanation": "This script makes the sprite display a thought bubble saying 'What should I do?' for 2 seconds when clicked."
+                }
+            ]
+        },
+        {
+            "block_name": "think ()",
+            "block_type": "Looks",
+            "block_shape": "Stack Block",
+            "op_code": "looks_think",
+            "functionality": "Displays a thought bubble with the specified text indefinitely until another 'say' or 'think' block is activated.",
+            "inputs": [
+                {
+                    "name": "MESSAGE",
+                    "type": "string"
+                }
+            ],
+            "example_standalone": "think [Got it! v]",
+            "example_with_other_blocks": [
+                {
+                    "script": "when I receive [correct answer v]\n   think [That's right! v]\n   wait (1) seconds\n   think [good v] \nend",
+                    "explanation": "This script makes the sprite think 'That's right!' for 1 second when a 'correct answer' broadcast is received, then clears the thought bubble."
+                }
+            ]
+        },
+        {
+            "block_name": "switch costume to ()",
+            "block_type": "Looks",
+            "block_shape": "Stack Block",
+            "op_code": "looks_switchcostumeto",
+            "functionality": "Alters the sprite's appearance to a designated costume.",
+            "inputs": [
+                {
+                    "name": "COSTUME",
+                    "type": "dropdown/number"
+                }
+            ],
+            "example_standalone": "switch costume to [costume1 v]",
+            "example_with_other_blocks": [
+                {
+                    "script": "when I receive [explosion v]\n   repeat (5)\n     next costume\n   end\n   hide[costume1 v] \nend",
+                    "explanation": "This script animates an explosion by rapidly switching costumes, then hides the sprite. [3]"
+                }
+            ]
+        },
+        {
+            "block_name": "next costume",
+            "block_type": "Looks",
+            "block_shape": "Stack Block",
+            "op_code": "looks_nextcostume",
+            "functionality": "Switches the sprite's costume to the next one in its costume list. If it's the last costume, it cycles back to the first.",
+            "inputs": null,
+            "example_standalone": "next costume",
+            "example_with_other_blocks": [
+                {
+                    "script": "when [space v] key pressed\n  repeat (3)\n    next costume\n    wait (0.1) seconds\n  end \nend",
+                    "explanation": "When the space key is pressed, the sprite will cycle through its next three costumes with a short delay between each change."
+                },
+                {
+                    "script": "when green flag clicked\n   forever\n     next costume\n     wait (0.2) seconds\n   end \nend",
+                    "explanation": "This script continuously animates the sprite by switching to the next costume every 0.2 seconds, creating a walking or flying effect."
+                }
+            ]
+        },
+        {
+            "block_name": "switch backdrop to ()",
+            "block_type": "Looks",
+            "block_shape": "Stack Block",
+            "op_code": "looks_switchbackdropto",
+            "functionality": "Changes the stage's backdrop to a specified backdrop.",
+            "inputs": [
+                {
+                    "name": "BACKDROP",
+                    "type": "dropdown/number"
+                }
+            ],
+            "example_standalone": "switch backdrop to [backdrop1 v]",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n   switch backdrop to [start screen v]\nend ",
+                    "explanation": "This script sets the stage to a 'start screen' backdrop when the project begins."
+                }
+            ]
+        },
+        {
+            "block_name": "switch backdrop to () and wait",
+            "block_type": "Looks",
+            "block_shape": "Stack Block",
+            "op_code": "looks_switchbackdroptowait",
+            "functionality": "Changes the stage's backdrop to a specified backdrop and pauses the script until any 'When backdrop switches to' scripts for that backdrop have finished.",
+            "inputs": [
+                {
+                    "name": "BACKDROP",
+                    "type": "dropdown/number"
+                }
+            ],
+            "example_standalone": "switch backdrop to [game over v] and wait",
+            "example_with_other_blocks": [
+                {
+                    "script": "broadcast [game over v]\n   switch backdrop to [game over v] and wait\n   stop [all v] \nend",
+                    "explanation": "This script broadcasts a 'game over' message, then changes the backdrop to 'game over' and waits for any associated scripts to finish before stopping all processes."
+                }
+            ]
+        },
+        {
+            "block_name": "next backdrop",
+            "block_type": "Looks",
+            "block_shape": "Stack Block",
+            "op_code": "looks_nextbackdrop",
+            "functionality": "Switches the stage's backdrop to the next one in its backdrop list. If it's the last backdrop, it cycles back to the first.",
+            "inputs": null,
+            "example_standalone": "next backdrop",
+            "example_with_other_blocks": [
+                {
+                    "script": "when [space v] key pressed\n   next backdrop\nend",
+                    "explanation": "This script changes the stage to the next backdrop in the list each time the space key is pressed."
+                }
+            ]
+        },
+        {
+            "block_name": "change size by ()",
+            "block_type": "Looks",
+            "block_shape": "Stack Block",
+            "op_code": "looks_changesizeby",
+            "functionality": "Changes the sprite's size by a specified percentage. Positive values make it larger, negative values make it smaller.",
+            "inputs": [
+                {
+                    "name": "CHANGE",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "change size by (10)",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n   repeat (10)\n     change size by (5)\n     wait (0.1) seconds\n   end \nend ",
+                    "explanation": "This script makes the sprite gradually grow larger over 10 steps, with a short pause between each size change."
+                }
+            ]
+        },
+        {
+            "block_name": "set size to ()",
+            "block_type": "Looks",
+            "block_shape": "Stack Block",
+            "op_code": "looks_setsizeto",
+            "functionality": "Sets the sprite's size to a specific percentage of its original size.",
+            "inputs": [
+                {
+                    "name": "SIZE",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "set size to (100)",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n   set size to (50)\n   wait (1) seconds\n   set size to (100) \nend ",
+                    "explanation": "This script makes the sprite shrink to half its original size at the start, waits for 1 second, then returns to its original size."
+                }
+            ]
+        },
+        {
+            "block_name": "change () effect by ()",
+            "block_type": "Looks",
+            "block_shape": "Stack Block",
+            "op_code": "looks_changeeffectby",
+            "functionality": "Changes a visual effect on the sprite by a specified amount (e.g., color, fisheye, whirl, pixelate, mosaic, brightness, ghost).",
+            "inputs": [
+                {
+                    "name": "EFFECT",
+                    "type": "dropdown",
+                    "options": [
+                        "color",
+                        "fisheye",
+                        "whirl",
+                        "pixelate",
+                        "mosaic",
+                        "brightness",
+                        "ghost"
+                    ]
+                },
+                {
+                    "name": "CHANGE",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "change [color v] effect by (25)",
+            "example_with_other_blocks": [
+                {
+                    "script": "when loudness > (10)\n  change [fisheye v] effect by (5)\nend",
+                    "explanation": "When the loudness detected by the microphone is greater than 10, the sprite's fisheye effect will increase by 5."
+                },
+                {
+                    "script": "when green flag clicked\n   forever\n     change [color v] effect by (5)\n     wait (0.1) seconds\n  end \nend",
+                    "explanation": "This script makes the sprite continuously cycle through different colors."
+                }
+            ]
+        },
+        {
+            "block_name": "set () effect to ()",
+            "block_type": "Looks",
+            "block_shape": "Stack Block",
+            "op_code": "looks_seteffectto",
+            "functionality": "Sets a visual effect on the sprite to a specific value.",
+            "inputs": [
+                {
+                    "name": "EFFECT",
+                    "type": "dropdown",
+                    "options": [
+                        "color",
+                        "fisheye",
+                        "whirl",
+                        "pixelate",
+                        "mosaic",
+                        "brightness",
+                        "ghost"
+                    ]
+                },
+                {
+                    "name": "VALUE",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "set [ghost v] effect to (50)",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n   set [ghost v] effect to (75)\nend",
+                    "explanation": "This script makes the sprite 75% transparent at the start of the project."
+                }
+            ]
+        },
+        {
+            "block_name": "clear graphic effects",
+            "block_type": "Looks",
+            "block_shape": "Stack Block",
+            "op_code": "looks_cleargraphiceffects",
+            "functionality": "Removes all visual effects applied to the sprite.",
+            "inputs": null,
+            "example_standalone": "clear graphic effects",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n   change [color v] effect by (50)\n   wait (2) seconds\n   clear graphic effects\nend",
+                    "explanation": "This script changes the sprite's color effect, waits 2 seconds, then resets all graphic effects."
+                }
+            ]
+        },
+        {
+            "block_name": "show",
+            "block_type": "Looks",
+            "block_shape": "Stack Block",
+            "op_code": "looks_show",
+            "functionality": "Makes the sprite visible on the stage.",
+            "inputs": null,
+            "example_standalone": "show",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n   hide[start game v]\nwhen I receive [start game v]\n   show [start game v] \nend", 
+                    "explanation": "This script hides the sprite at the beginning of the project and makes it visible when a 'start game' broadcast is received."
+                }
+            ]
+        },
+        {
+            "block_name": "hide",
+            "block_type": "Looks",
+            "block_shape": "Stack Block",
+            "op_code": "looks_hide",
+            "functionality": "Makes the sprite invisible on the stage.",
+            "inputs": null,
+            "example_standalone": "hide",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n   hide \nend",
+                    "explanation": "This script hides the sprite from the stage when the green flag is clicked."
+                }
+            ]
+        },
+        {
+            "block_name": "go to () layer",
+            "block_type": "Looks",
+            "block_shape": "Stack Block",
+            "op_code": "looks_gotofrontback",
+            "functionality": "Moves the sprite to the front-most or back-most layer of other sprites on the stage.",
+            "inputs": [
+                {
+                    "name": "FRONT_BACK",
+                    "type": "dropdown",
+                    "options": [
+                        "front",
+                        "back"
+                    ]
+                }
+            ],
+            "example_standalone": "go to [front v] layer",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n   go to [front v] layer\nend",
+                    "explanation": "This script ensures the sprite is always visible on top of other sprites at the start of the project."
+                }
+            ]
+        },
+        {
+            "block_name": "go () layers",
+            "block_type": "Looks",
+            "block_shape": "Stack Block",
+            "op_code": "looks_goforwardbackwardlayers",
+            "functionality": "Moves the sprite forward or backward a specified number of layers in relation to other sprites.",
+            "inputs": [
+                {
+                    "name": "FORWARD_BACKWARD",
+                    "type": "dropdown",
+                    "options": [
+                        "forward",
+                        "backward"
+                    ]
+                },
+                {
+                    "name": "NUM",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "go [forward v] (1) layers",
+            "example_with_other_blocks": [
+                {
+                    "script": "when this sprite clicked go [forward v] (1) layers\nend",
+                    "explanation": "This script brings the clicked sprite one layer closer to the front."
+                }
+            ]
+        },
+        {
+            "block_name": "play sound () until done",
+            "block_type": "Sound",
+            "block_shape": "Stack Block",
+            "op_code": "sound_playuntildone",
+            "functionality": "Plays a specified sound and pauses the script's execution until the sound has completed.",
+            "inputs": [
+                {
+                    "name": "sound name",
+                    "type": "dropdown"
+                }
+            ],
+            "example_standalone": "play sound [Meow v] until done",
+            "example_with_other_blocks": [
+                {
+                    "script": "when backdrop switches to [winning screen v]\n  play sound [fanfare v] until done\n  say [You won!] for (2) seconds\nend",
+                    "explanation": "When the backdrop changes to the 'winning screen', a 'fanfare' sound will play until it finishes, and then the sprite will say 'You won!' for 2 seconds."
+                },
+                {
+                    "script": "forever\n   play sound [Music v] until done \nend",
+                    "explanation": "This script creates a continuous loop for background music, playing the 'Music' sound repeatedly."
+                }
+            ]
+        },
+        {
+            "block_name": "start sound ()",
+            "block_type": "Sound",
+            "block_shape": "Stack Block",
+            "op_code": "sound_play",
+            "functionality": "Initiates playback of a specified sound without pausing the script, allowing other actions to proceed concurrently.",
+            "inputs": [
+                {
+                    "name": "sound name",
+                    "type": "dropdown"
+                }
+            ],
+            "example_standalone": "start sound [Pop v]",
+            "example_with_other_blocks": [
+                {
+                    "script": "when this sprite clicked\n   start sound [Pop v]\n   change [score v] by (1)\nend",
+                    "explanation": "This script plays a 'Pop' sound and increments the score simultaneously when the sprite is clicked."
+                }
+            ]
+        },
+        {
+            "block_name": "stop all sounds",
+            "block_type": "Sound",
+            "block_shape": "Stack Block",
+            "op_code": "sound_stopallsounds",
+            "functionality": "Stops all currently playing sounds.",
+            "inputs": null,
+            "example_standalone": "stop all sounds",
+            "example_with_other_blocks": [
+                {
+                    "script": "when I receive [game over v]\n   stop all sounds\nend",
+                    "explanation": "This script stops any sounds currently playing when the 'game over' broadcast is received."
+                }
+            ]
+        },
+        {
+            "block_name": "change volume by ()",
+            "block_type": "Sound",
+            "block_shape": "Stack Block",
+            "op_code": "sound_changevolumeby",
+            "functionality": "Changes the project's sound volume by a specified amount.",
+            "inputs": [
+                {
+                    "name": "change",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "change volume by (-10)",
+            "example_with_other_blocks": [
+                {
+                    "script": "when [down arrow v] key pressed\n   change volume by (-5)\nend",
+                    "explanation": "This script decreases the project's volume by 5 when the down arrow key is pressed."
+                }
+            ]
+        },
+        {
+            "block_name": "set volume to () %",
+            "block_type": "Sound",
+            "block_shape": "Stack Block",
+            "op_code": "sound_setvolumeto",
+            "functionality": "Sets the sound volume to a specific percentage (0-100).",
+            "inputs": [
+                {
+                    "name": "percentage",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "set volume to (100) %",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n   set volume to (50) %\nend",
+                    "explanation": "This script sets the project's volume to 50% when the green flag is clicked."
+                }
+            ]
+        },
+        {
+            "block_name": "broadcast ()",
+            "block_type": "Events",
+            "block_shape": "Stack Block",
+            "op_code": "event_broadcast",
+            "functionality": "Sends a broadcast message throughout the Scratch program, activating any 'when I receive ()' blocks that are set to listen for that message, enabling indirect communication.",
+            "inputs": [
+                {
+                    "name": "message name",
+                    "type": "string/dropdown"
+                }
+            ],
+            "example_standalone": "broadcast [start game v]",
+            "example_with_other_blocks": [
+                {
+                    "script": "if <key [space v] pressed?> then\n  broadcast [jump v]\nend",
+                    "explanation": "This script sends a 'jump' message to other scripts or sprites when the space key is pressed."
+                }
+            ]
+        },
+        {
+            "block_name": "broadcast () and wait",
+            "block_type": "Events",
+            "block_shape": "Stack Block",
+            "op_code": "event_broadcastandwait",
+            "functionality": "Sends a broadcast message and pauses the current script until all other scripts activated by that broadcast have completed their execution, ensuring sequential coordination.",
+            "inputs": [
+                {
+                    "name": "message name",
+                    "type": "string/dropdown"
+                }
+            ],
+            "example_standalone": "broadcast [initialize sprites v] and wait",
+            "example_with_other_blocks": [
+                {
+                    "script": "broadcast [initialize sprites v] and wait\n  say [Game Started!] for (2) seconds",
+                    "explanation": "This script ensures all sprite initialization routines complete before displaying 'Game Started!' for 2 seconds."
+                }
+            ]
+        },
+        {
+            "block_name": "wait () seconds",
+            "block_type": "Control",
+            "block_shape": "Stack Block",
+            "op_code": "control_wait",
+            "functionality": "Pauses the script for a specified duration.",
+            "inputs": [
+                {
+                    "name": "seconds",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "wait (1) seconds",
+            "example_with_other_blocks": [
+                {
+                    "script": "say [Hello!] for (1) seconds\n   wait (0.5) seconds\n   say [Goodbye!] for (1) seconds",
+                    "explanation": "This script creates a timed dialogue sequence, pausing for 0.5 seconds between two speech bubbles."
+                }
+            ]
+        },
+        {
+            "block_name": "wait until <>",
+            "block_type": "Control",
+            "block_shape": "Stack Block",
+            "op_code": "control_wait_until",
+            "functionality": "Pauses the script until the specified boolean condition becomes true. [NOTE: it takes boolean blocks as input]",
+            "inputs": [
+                {
+                    "name": "condition",
+                    "type": "boolean"
+                }
+            ],
+            "example_standalone": "wait until <key [space v] pressed?>",
+            "example_with_other_blocks": [
+                {
+                    "script": "wait until <key [space v] pressed?>\n   start sound [pop v]\nend",
+                    "explanation": "This script pauses until the space key is pressed, then plays a 'pop' sound."
+                }
+            ]
+        },
+        {
+            "block_name": "stop ()",
+            "block_type": "Control",
+            "block_shape": "Stack Block",
+            "op_code": "control_stop",
+            "functionality": "Stops all scripts, this script, or other scripts in the sprite. Becomes a Cap Block if 'all' or 'this script' is selected in the dropdown menu.",
+            "inputs": [
+                {
+                    "name": "option",
+                    "type": "dropdown",
+                    "options": [
+                        "all",
+                        "this script",
+                        "other scripts in sprite"
+                    ]
+                }
+            ],
+            "example_standalone": "stop [all v]",
+            "example_with_other_blocks": [
+                {
+                    "script": "if <score = (0)> then\n   stop [all v]\nend",
+                    "explanation": "This script stops the entire project if the 'score' variable becomes 0."
+                }
+            ]
+        },
+        {
+            "block_name": "create clone of ()",
+            "block_type": "Control",
+            "block_shape": "Stack Block",
+            "op_code": "control_create_clone_of",
+            "functionality": "Generates a copy, or clone, of a specified sprite (or 'myself' for the current sprite).",
+            "inputs": [
+                {
+                    "name": "sprite_name",
+                    "type": "dropdown",
+                    "options": [
+                        "myself",
+                        "sprite1",
+                        "..."
+                    ]
+                }
+            ],
+            "example_standalone": "create clone of [myself v]",
+            "example_with_other_blocks": [
+                {
+                    "script": "when I start as a clone\n  show\n  go to random position\n  wait (2) seconds\n  delete this clone\nend",
+                    "explanation": "When a clone is created, it will show itself, go to a random position, wait for 2 seconds, and then delete itself."
+                }
+            ]
+        },
+        {
+            "block_name": "delete this clone",
+            "block_type": "Control",
+            "block_shape": "Stack Block",
+            "op_code": "control_delete_this_clone",
+            "functionality": "Deletes the clone that is currently running the script.",
+            "inputs": null,
+            "example_standalone": "delete this clone",
+            "example_with_other_blocks": [
+                {
+                    "script": "when I start as a clone\n   wait (5) seconds\n   delete this clone\nend",
+                    "explanation": "This script makes each clone wait for 5 seconds after it's created, then deletes itself."
+                }
+            ]
+        },
+        {
+            "block_name": "set [my variable v] to ()",
+            "block_type": "Data",
+            "block_shape": "Stack Block",
+            "op_code": "data_setvariableto",
+            "functionality": "Assigns a specific value (number, string, or boolean) to a variable.",
+            "inputs": [
+                {
+                    "name": "variable name",
+                    "type": "dropdown"
+                },
+                {
+                    "name": "value",
+                    "type": "any"
+                }
+            ],
+            "example_standalone": "set [score v] to (0)",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n  set [score v] to (0)\n  set [player name v] to [Guest]\nend",
+                    "explanation": "This script initializes the 'score' variable to 0 and the 'player name' variable to 'Guest' when the project starts."
+                }
+            ]
+        },
+        {
+            "block_name": "change [my variable v] by ()",
+            "block_type": "Data",
+            "block_shape": "Stack Block",
+            "op_code": "data_changevariableby",
+            "functionality": "Increases or decreases a variable's numerical value by a specified amount.",
+            "inputs": [
+                {
+                    "name": "variable name",
+                    "type": "dropdown"
+                },
+                {
+                    "name": "value",
+                    "type": "number"
+                }
+            ],
+            "example_standalone": "change [score v] by (1)",
+            "example_with_other_blocks": [
+                {
+                    "script": "when this sprite clicked\n  change [score v] by (1)\nend",
+                    "explanation": "This script increments the 'score' variable by 1 each time the sprite is clicked."
+                }
+            ]
+        },
+        {
+            "block_name": "add () to [my list v]",
+            "block_type": "Data",
+            "block_shape": "Stack Block",
+            "op_code": "data_addtolist",
+            "functionality": "Appends an item to the end of a list.",
+            "inputs": [
+                {
+                    "name": "item",
+                    "type": "any"
+                },
+                {
+                    "name": "list name",
+                    "type": "dropdown"
+                }
+            ],
+            "example_standalone": "add [apple] to [shopping list v]",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n  add [apple] to [shopping list v]\n  add [banana] to [shopping list v]\nend",
+                    "explanation": "This script adds 'apple' and 'banana' as new items to the 'shopping list' when the project starts."
+                }
+            ]
+        },
+        {
+            "block_name": "delete () of [my list v]",
+            "block_type": "Data",
+            "block_shape": "Stack Block",
+            "op_code": "data_deleteoflist",
+            "functionality": "Removes an item from a list by its index or by selecting 'all' items.",
+            "inputs": [
+                {
+                    "name": "index/option",
+                    "type": "number/dropdown",
+                    "options": [
+                        "all",
+                        "last",
+                        "random"
+                    ]
+                },
+                {
+                    "name": "list name",
+                    "type": "dropdown"
+                }
+            ],
+            "example_standalone": "delete (1) of [my list v]",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n  delete (all) of [my list v]\nend",
+                    "explanation": "This script clears all items from 'my list' when the green flag is clicked."
+                }
+            ]
+        },
+        {
+            "block_name": "insert () at () of [my list v]",
+            "block_type": "Data",
+            "block_shape": "Stack Block",
+            "op_code": "data_insertatlist",
+            "functionality": "Inserts an item at a specific position within a list.",
+            "inputs": [
+                {
+                    "name": "item",
+                    "type": "any"
+                },
+                {
+                    "name": "index",
+                    "type": "number"
+                },
+                {
+                    "name": "list name",
+                    "type": "dropdown"
+                }
+            ],
+            "example_standalone": "insert [orange] at (2) of [fruits v]",
+            "example_with_other_blocks": [
+                {
+                    "script": "insert [orange] at (2) of [fruits v]",
+                    "explanation": "This script inserts 'orange' as the second item in the 'fruits' list, shifting subsequent items."
+                }
+            ]
+        },
+        {
+            "block_name": "replace item () of [my list v] with ()",
+            "block_type": "Data",
+            "block_shape": "Stack Block",
+            "op_code": "data_replaceitemoflist",
+            "functionality": "Replaces an item at a specific position in a list with a new value.",
+            "inputs": [
+                {
+                    "name": "index",
+                    "type": "number"
+                },
+                {
+                    "name": "list name",
+                    "type": "dropdown"
+                },
+                {
+                    "name": "new item",
+                    "type": "any"
+                }
+            ],
+            "example_standalone": "replace item (1) of [colors v] with [blue]",
+            "example_with_other_blocks": [
+                {
+                    "script": "replace item (1) of [colors v] with [blue]",
+                    "explanation": "This script changes the first item in the 'colors' list to 'blue'."
+                }
+            ]
+        },
+        {
+            "block_name": "show variable [my variable v]",
+            "block_type": "Data",
+            "block_shape": "Stack Block",
+            "op_code": "data_showvariable",
+            "functionality": "Makes a variable's monitor visible on the stage.",
+            "inputs": [
+                {
+                    "name": "variable name",
+                    "type": "dropdown"
+                }
+            ],
+            "example_standalone": "show variable [score v]",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n  show variable [score v]\nend",
+                    "explanation": "This script displays the 'score' variable on the stage when the project starts."
+                }
+            ]
+        },
+        {
+            "block_name": "hide variable [my variable v]",
+            "block_type": "Data",
+            "block_shape": "Stack Block",
+            "op_code": "data_hidevariable",
+            "functionality": "Hides a variable's monitor from the stage.",
+            "inputs": [
+                {
+                    "name": "variable name",
+                    "type": "dropdown"
+                }
+            ],
+            "example_standalone": "hide variable [score v]",
+            "example_with_other_blocks": [
+                {
+                    "script": "when I receive [game over v]\n  hide variable [score v]\nend",
+                    "explanation": "This script hides the 'score' variable when the 'game over' broadcast is received."
+                }
+            ]
+        },
+        {
+            "block_name": "show list [my list v]",
+            "block_type": "Data",
+            "block_shape": "Stack Block",
+            "op_code": "data_showlist",
+            "functionality": "Makes a list's monitor visible on the stage.",
+            "inputs": [
+                {
+                    "name": "list name",
+                    "type": "dropdown"
+                }
+            ],
+            "example_standalone": "show list [shopping list v]",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n  show list [shopping list v]\nend",
+                    "explanation": "This script displays the 'shopping list' on the stage when the project starts."
+                }
+            ]
+        },
+        {
+            "block_name": "hide list [my list v]",
+            "block_type": "Data",
+            "block_shape": "Stack Block",
+            "op_code": "data_hidelist",
+            "functionality": "Hides a list's monitor from the stage.",
+            "inputs": [
+                {
+                    "name": "list name",
+                    "type": "dropdown"
+                }
+            ],
+            "example_standalone": "hide list [shopping list v]",
+            "example_with_other_blocks": [
+                {
+                    "script": "when I receive [game over v]\n  hide list [shopping list v]\nend",
+                    "explanation": "This script hides the 'shopping list' when the 'game over' broadcast is received."
+                }
+            ]
+        },
+        {
+            "block_name": "Ask () and Wait",
+            "block_type": "Sensing",
+            "block_shape": "Stack Block",
+            "op_code": "sensing_askandwait",
+            "functionality": "Displays an input box with specified text at the bottom of the screen, allowing users to input text, which is stored in the 'Answer' block.",
+            "inputs": [
+                {
+                    "name": "question",
+                    "type": "text"
+                }
+            ],
+            "example_standalone": "ask [What is your name? v] and wait",
+            "example_with_other_blocks": [
+                {
+                    "script": "ask [What is your name? v] and wait\n  say join [Hello v] (answer) for (2) seconds \nend",
+                    "explanation": "This script prompts the user for their name, waits for input, then greets them using the provided answer."
+                }
+            ]
+        },
+        {
+            "block_name": "Reset Timer",
+            "block_type": "Sensing",
+            "block_shape": "Stack Block",
+            "op_code": "sensing_resettimer",
+            "functionality": "Sets the timer’s value back to 0.0.",
+            "inputs": null,
+            "example_standalone": "reset timer",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n  reset timer\n  wait (5) seconds\n  say timer for (2) seconds\nend",
+                    "explanation": "This script resets the timer at the start, waits for 5 seconds, then says the current timer value."
+                }
+            ]
+        },
+        {
+            "block_name": "set drag mode [draggable v]",
+            "block_type": "Sensing",
+            "block_shape": "Stack Block",
+            "op_code": "sensing_setdragmode",
+            "functionality": "Sets whether the sprite can be dragged by the mouse on the stage.",
+            "inputs": null,
+            "fields": {
+                "DRAG_MODE": {
+                    "type": "dropdown",
+                    "options": [
+                        "draggable",
+                        "not draggable"
+                    ]
+                }
+            },
+            "example_standalone": "set drag mode [draggable v]",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n  set drag mode [not draggable v]\nend when this sprite clicked\n  set drag mode [draggable v] \nend",
+                    "explanation": "This script makes the sprite not draggable when the project starts, but allows it to be dragged once it's clicked."
+                }
+            ]
+        },
+        {
+            "block_name": "[my custom block]",
+            "block_type": "My Blocks",
+            "block_shape": "Stack Block",
+            "op_code": "procedures_call",
+            "functionality": "Executes the script defined by a corresponding 'define' Hat block. This block allows users to call and reuse custom code sequences by simply dragging and dropping it into their scripts, optionally providing required input values.",
+            "inputs": [
+                {
+                    "name": "argument_name_1",
+                    "type": "any"
+                },
+                {
+                    "name": "argument_name_2",
+                    "type": "any"
+                }
+            ],
+            "example_standalone": "jump (50)",
+            "example_with_other_blocks": [
+                {
+                    "script": "when green flag clicked\n  go to x: (0) y: (0)\n  jump (50)\n  wait (1) seconds\n  say [I jumped!] for (2) seconds",
+                    "explanation": "This script moves the sprite to a starting position, then calls the 'jump' custom block with an input of 50 (assuming 'jump' is a custom block that moves the sprite up and down). After the jump, the sprite says 'I jumped!'."
+                },
+                {
+                    "script": "when green flag clicked\n   hide\n   forever\n     create clone of [myself v]\n     wait (1) seconds\n   end",
+                    "explanation": "This script continuously creates new clones of the current sprite every second after the original sprite hides itself."
+                }
+            ]
+        }
+    ]
+}

chat_agent/__init__.py

@@ -0,0 +1 @@
+# Multi-language Chat Agent Package

chat_agent/api/README.md

@@ -0,0 +1,898 @@
+# Chat Agent API Documentation
+
+This document describes the REST API endpoints for the multi-language chat agent.
+
+## Base URL
+
+All API endpoints are prefixed with `/api/v1/chat`
+
+## Authentication
+
+All endpoints (except health check and supported languages) require authentication via one of the following methods:
+
+### Header-based Authentication (Development)
+```
+X-User-ID: your-user-id
+```
+
+### Token-based Authentication (Production)
+```
+Authorization: Bearer your-session-token
+```
+
+## Rate Limiting
+
+The API implements rate limiting to prevent abuse:
+- Default: 200 requests per day, 50 requests per hour
+- Session creation: 10 requests per minute
+- Session deletion: 5 requests per minute
+- Other endpoints: 20-30 requests per minute
+
+Rate limit exceeded responses return HTTP 429 with retry information.
+
+## Endpoints
+
+### 1. Get Supported Languages
+
+Get a list of all supported programming languages.
+
+**Endpoint:** `GET /api/v1/chat/languages`
+
+**Authentication:** Not required
+
+**Response:**
+```json
+{
+  "languages": [
+    {
+      "code": "python",
+      "name": "Python",
+      "syntax_highlighting": "python",
+      "file_extensions": [".py", ".pyw"]
+    },
+    {
+      "code": "javascript",
+      "name": "JavaScript", 
+      "syntax_highlighting": "javascript",
+      "file_extensions": [".js", ".mjs"]
+    }
+  ],
+  "default_language": "python",
+  "total_count": 8
+}
+```
+
+### 2. Create Chat Session
+
+Create a new chat session for a user.
+
+**Endpoint:** `POST /api/v1/chat/sessions`
+
+**Authentication:** Required
+
+**Request Body:**
+```json
+{
+  "language": "python",
+  "metadata": {
+    "source": "web_app",
+    "user_preferences": {}
+  }
+}
+```
+
+**Response (201 Created):**
+```json
+{
+  "session_id": "uuid-string",
+  "user_id": "user-123",
+  "language": "python",
+  "created_at": "2023-01-01T00:00:00",
+  "message_count": 0,
+  "metadata": {
+    "source": "web_app"
+  }
+}
+```
+
+**Error Responses:**
+- `400 Bad Request`: Invalid language or missing required fields
+- `401 Unauthorized`: Missing or invalid authentication
+- `429 Too Many Requests`: Rate limit exceeded
+
+### 3. Get Chat Session
+
+Retrieve information about a specific chat session.
+
+**Endpoint:** `GET /api/v1/chat/sessions/{session_id}`
+
+**Authentication:** Required (must own the session)
+
+**Response (200 OK):**
+```json
+{
+  "session_id": "uuid-string",
+  "user_id": "user-123",
+  "language": "python",
+  "created_at": "2023-01-01T00:00:00",
+  "last_active": "2023-01-01T01:00:00",
+  "message_count": 5,
+  "is_active": true,
+  "metadata": {}
+}
+```
+
+**Error Responses:**
+- `403 Forbidden`: Session belongs to different user
+- `404 Not Found`: Session does not exist
+- `410 Gone`: Session has expired
+
+### 4. List User Sessions
+
+Get all sessions for the authenticated user.
+
+**Endpoint:** `GET /api/v1/chat/sessions`
+
+**Authentication:** Required
+
+**Query Parameters:**
+- `active_only` (boolean, default: true): Only return active sessions
+
+**Response (200 OK):**
+```json
+{
+  "sessions": [
+    {
+      "session_id": "uuid-string",
+      "language": "python",
+      "created_at": "2023-01-01T00:00:00",
+      "last_active": "2023-01-01T01:00:00",
+      "message_count": 5,
+      "is_active": true,
+      "metadata": {}
+    }
+  ],
+  "total_count": 1,
+  "active_only": true
+}
+```
+
+### 5. Delete Chat Session
+
+Delete a chat session and all associated data.
+
+**Endpoint:** `DELETE /api/v1/chat/sessions/{session_id}`
+
+**Authentication:** Required (must own the session)
+
+**Response (200 OK):**
+```json
+{
+  "message": "Session deleted successfully",
+  "session_id": "uuid-string",
+  "messages_deleted": 10
+}
+```
+
+**Error Responses:**
+- `403 Forbidden`: Session belongs to different user
+- `404 Not Found`: Session does not exist
+
+### 6. Get Chat History
+
+Retrieve chat history for a session.
+
+**Endpoint:** `GET /api/v1/chat/sessions/{session_id}/history`
+
+**Authentication:** Required (must own the session)
+
+**Query Parameters:**
+- `page` (integer, default: 1): Page number for pagination
+- `page_size` (integer, default: 50, max: 100): Messages per page
+- `recent_only` (boolean, default: false): Get only recent messages
+- `limit` (integer, default: 10, max: 50): Number of recent messages (when recent_only=true)
+
+**Response (200 OK):**
+```json
+{
+  "messages": [
+    {
+      "id": "uuid-string",
+      "role": "user",
+      "content": "Hello, can you help me with Python?",
+      "language": "python",
+      "timestamp": "2023-01-01T00:00:00",
+      "metadata": {}
+    },
+    {
+      "id": "uuid-string",
+      "role": "assistant", 
+      "content": "Of course! I'd be happy to help you with Python.",
+      "language": "python",
+      "timestamp": "2023-01-01T00:01:00",
+      "metadata": {
+        "tokens": 15
+      }
+    }
+  ],
+  "session_id": "uuid-string",
+  "total_count": 2,
+  "page": 1,
+  "page_size": 50,
+  "total_pages": 1
+}
+```
+
+### 7. Search Chat History
+
+Search messages within a session.
+
+**Endpoint:** `GET /api/v1/chat/sessions/{session_id}/history/search`
+
+**Authentication:** Required (must own the session)
+
+**Query Parameters:**
+- `q` (string, required, min: 3 chars): Search query
+- `limit` (integer, default: 20, max: 50): Maximum results
+
+**Response (200 OK):**
+```json
+{
+  "messages": [
+    {
+      "id": "uuid-string",
+      "role": "user",
+      "content": "How do I use Python lists?",
+      "language": "python",
+      "timestamp": "2023-01-01T00:00:00",
+      "metadata": {}
+    }
+  ],
+  "session_id": "uuid-string",
+  "query": "Python",
+  "result_count": 1
+}
+```
+
+**Error Responses:**
+- `400 Bad Request`: Query too short or missing
+
+### 8. Get Language Context
+
+Get the current language context for a session.
+
+**Endpoint:** `GET /api/v1/chat/sessions/{session_id}/language`
+
+**Authentication:** Required (must own the session)
+
+**Response (200 OK):**
+```json
+{
+  "session_id": "uuid-string",
+  "language": "python",
+  "prompt_template": "You are a helpful Python programming assistant...",
+  "syntax_highlighting": "python",
+  "language_info": {
+    "name": "Python",
+    "syntax_highlighting": "python",
+    "file_extensions": [".py", ".pyw"],
+    "prompt_template": "..."
+  },
+  "updated_at": "2023-01-01T00:00:00"
+}
+```
+
+### 9. Update Language Context
+
+Change the programming language for a session.
+
+**Endpoint:** `PUT /api/v1/chat/sessions/{session_id}/language`
+
+**Authentication:** Required (must own the session)
+
+**Request Body:**
+```json
+{
+  "language": "javascript"
+}
+```
+
+**Response (200 OK):**
+```json
+{
+  "session_id": "uuid-string",
+  "language": "javascript",
+  "prompt_template": "You are a helpful JavaScript programming assistant...",
+  "syntax_highlighting": "javascript",
+  "language_info": {
+    "name": "JavaScript",
+    "syntax_highlighting": "javascript",
+    "file_extensions": [".js", ".mjs"],
+    "prompt_template": "..."
+  },
+  "updated_at": "2023-01-01T01:00:00"
+}
+```
+
+**Error Responses:**
+- `400 Bad Request`: Unsupported language
+
+### 10. Health Check
+
+Check the health status of the API and its dependencies.
+
+**Endpoint:** `GET /api/v1/chat/health`
+
+**Authentication:** Not required
+
+**Response (200 OK):**
+```json
+{
+  "status": "healthy",
+  "timestamp": "2023-01-01T00:00:00",
+  "services": {
+    "database": "connected",
+    "redis": "connected"
+  }
+}
+```
+
+**Response (503 Service Unavailable):**
+```json
+{
+  "status": "unhealthy",
+  "timestamp": "2023-01-01T00:00:00",
+  "error": "Database connection failed"
+}
+```
+
+## Error Responses
+
+All error responses follow a consistent format:
+
+```json
+{
+  "error": "Error type",
+  "message": "Detailed error message"
+}
+```
+
+### Common HTTP Status Codes
+
+- `200 OK`: Request successful
+- `201 Created`: Resource created successfully
+- `400 Bad Request`: Invalid request data
+- `401 Unauthorized`: Authentication required
+- `403 Forbidden`: Access denied
+- `404 Not Found`: Resource not found
+- `410 Gone`: Resource expired
+- `429 Too Many Requests`: Rate limit exceeded
+- `500 Internal Server Error`: Server error
+- `503 Service Unavailable`: Service temporarily unavailable
+
+## Security Considerations
+
+1. **Authentication**: All endpoints require valid authentication
+2. **Authorization**: Users can only access their own sessions
+3. **Rate Limiting**: Prevents abuse and manages API costs
+4. **Input Validation**: All inputs are validated and sanitized
+5. **Error Handling**: Errors don't expose sensitive information
+
+## Usage Examples
+
+### Create a Session and Send Messages
+
+```bash
+# Create session
+curl -X POST http://localhost:5000/api/v1/chat/sessions \
+  -H "X-User-ID: user-123" \
+  -H "Content-Type: application/json" \
+  -d '{"language": "python"}'
+
+# Get session info
+curl -X GET http://localhost:5000/api/v1/chat/sessions/{session_id} \
+  -H "X-User-ID: user-123"
+
+# Change language
+curl -X PUT http://localhost:5000/api/v1/chat/sessions/{session_id}/language \
+  -H "X-User-ID: user-123" \
+  -H "Content-Type: application/json" \
+  -d '{"language": "javascript"}'
+
+# Get chat history
+curl -X GET http://localhost:5000/api/v1/chat/sessions/{session_id}/history \
+  -H "X-User-ID: user-123"
+
+# Delete session
+curl -X DELETE http://localhost:5000/api/v1/chat/sessions/{session_id} \
+  -H "X-User-ID: user-123"
+```
+
+### JavaScript/TypeScript Example
+
+```javascript
+const API_BASE = 'http://localhost:5000/api/v1/chat';
+const USER_ID = 'user-123';
+
+// Create session
+const response = await fetch(`${API_BASE}/sessions`, {
+  method: 'POST',
+  headers: {
+    'X-User-ID': USER_ID,
+    'Content-Type': 'application/json'
+  },
+  body: JSON.stringify({
+    language: 'python',
+    metadata: { source: 'web_app' }
+  })
+});
+
+const session = await response.json();
+console.log('Created session:', session.session_id);
+
+// Get chat history
+const historyResponse = await fetch(
+  `${API_BASE}/sessions/${session.session_id}/history`,
+  {
+    headers: { 'X-User-ID': USER_ID }
+  }
+);
+
+const history = await historyResponse.json();
+console.log('Messages:', history.messages);
+```
+
+## WebSocket API Documentation
+
+The chat agent also supports real-time communication via WebSocket for interactive chat sessions.
+
+### WebSocket Connection
+
+**Endpoint:** `ws://localhost:5000/socket.io/`
+
+**Authentication:** Include user ID in connection query parameters or headers
+
+**Connection Example:**
+```javascript
+const socket = io('http://localhost:5000', {
+  query: { user_id: 'user-123' },
+  transports: ['websocket']
+});
+```
+
+### WebSocket Events
+
+#### 1. Connect Event
+Automatically triggered when client connects.
+
+**Client sends:**
+```javascript
+// Connection is automatic, but you can send auth data
+socket.emit('authenticate', {
+  user_id: 'user-123',
+  session_token: 'optional-token'
+});
+```
+
+**Server responds:**
+```javascript
+socket.on('connected', (data) => {
+  console.log(data);
+  // {
+  //   "status": "connected",
+  //   "user_id": "user-123",
+  //   "timestamp": "2023-01-01T00:00:00Z"
+  // }
+});
+```
+
+#### 2. Send Message Event
+Send a chat message to the assistant.
+
+**Client sends:**
+```javascript
+socket.emit('message', {
+  session_id: 'session-uuid',
+  content: 'How do I create a Python list?',
+  language: 'python',
+  metadata: {
+    source: 'web_chat',
+    timestamp: new Date().toISOString()
+  }
+});
+```
+
+**Server responds:**
+```javascript
+socket.on('message_response', (data) => {
+  console.log(data);
+  // {
+  //   "session_id": "session-uuid",
+  //   "message_id": "msg-uuid",
+  //   "content": "To create a Python list, you can use square brackets...",
+  //   "language": "python",
+  //   "timestamp": "2023-01-01T00:01:00Z",
+  //   "metadata": {
+  //     "tokens": 45,
+  //     "response_time": 0.85
+  //   }
+  // }
+});
+```
+
+#### 3. Streaming Response Event
+For real-time streaming responses.
+
+**Client sends:**
+```javascript
+socket.emit('message_stream', {
+  session_id: 'session-uuid',
+  content: 'Explain Python functions in detail',
+  language: 'python'
+});
+```
+
+**Server responds with multiple events:**
+```javascript
+socket.on('stream_start', (data) => {
+  // { "session_id": "session-uuid", "message_id": "msg-uuid" }
+});
+
+socket.on('stream_chunk', (data) => {
+  // { "session_id": "session-uuid", "chunk": "A Python function is..." }
+});
+
+socket.on('stream_end', (data) => {
+  // { "session_id": "session-uuid", "complete_response": "..." }
+});
+```
+
+#### 4. Language Switch Event
+Change the programming language context.
+
+**Client sends:**
+```javascript
+socket.emit('language_switch', {
+  session_id: 'session-uuid',
+  language: 'javascript'
+});
+```
+
+**Server responds:**
+```javascript
+socket.on('language_switched', (data) => {
+  // {
+  //   "session_id": "session-uuid",
+  //   "previous_language": "python",
+  //   "new_language": "javascript",
+  //   "timestamp": "2023-01-01T00:02:00Z"
+  // }
+});
+```
+
+#### 5. Typing Indicator Events
+Show when user or assistant is typing.
+
+**Client sends:**
+```javascript
+socket.emit('typing_start', {
+  session_id: 'session-uuid'
+});
+
+socket.emit('typing_stop', {
+  session_id: 'session-uuid'
+});
+```
+
+**Server responds:**
+```javascript
+socket.on('assistant_typing', (data) => {
+  // { "session_id": "session-uuid", "typing": true }
+});
+
+socket.on('assistant_typing_stop', (data) => {
+  // { "session_id": "session-uuid", "typing": false }
+});
+```
+
+#### 6. Error Events
+Handle various error conditions.
+
+**Server sends:**
+```javascript
+socket.on('error', (data) => {
+  console.error(data);
+  // {
+  //   "error": "session_not_found",
+  //   "message": "Session does not exist or has expired",
+  //   "session_id": "session-uuid",
+  //   "timestamp": "2023-01-01T00:03:00Z"
+  // }
+});
+```
+
+### Complete WebSocket Example
+
+```html
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Chat Agent WebSocket Example</title>
+    <script src="https://cdn.socket.io/4.0.0/socket.io.min.js"></script>
+</head>
+<body>
+    <div id="messages"></div>
+    <input type="text" id="messageInput" placeholder="Type your message...">
+    <select id="languageSelect">
+        <option value="python">Python</option>
+        <option value="javascript">JavaScript</option>
+        <option value="java">Java</option>
+    </select>
+    <button onclick="sendMessage()">Send</button>
+
+    <script>
+        const socket = io('http://localhost:5000', {
+            query: { user_id: 'demo-user' }
+        });
+
+        let currentSessionId = null;
+
+        // Create session first
+        fetch('/api/v1/chat/sessions', {
+            method: 'POST',
+            headers: {
+                'X-User-ID': 'demo-user',
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ language: 'python' })
+        })
+        .then(response => response.json())
+        .then(data => {
+            currentSessionId = data.session_id;
+            console.log('Session created:', currentSessionId);
+        });
+
+        // Handle connection
+        socket.on('connected', (data) => {
+            console.log('Connected to chat agent:', data);
+        });
+
+        // Handle messages
+        socket.on('message_response', (data) => {
+            addMessage('Assistant', data.content);
+        });
+
+        // Handle streaming
+        let streamBuffer = '';
+        socket.on('stream_chunk', (data) => {
+            streamBuffer += data.chunk;
+            updateStreamingMessage(streamBuffer);
+        });
+
+        socket.on('stream_end', (data) => {
+            addMessage('Assistant', data.complete_response);
+            streamBuffer = '';
+        });
+
+        // Handle language switches
+        socket.on('language_switched', (data) => {
+            console.log('Language switched:', data);
+            addMessage('System', `Language changed to ${data.new_language}`);
+        });
+
+        // Handle errors
+        socket.on('error', (data) => {
+            console.error('Chat error:', data);
+            addMessage('Error', data.message);
+        });
+
+        function sendMessage() {
+            const input = document.getElementById('messageInput');
+            const message = input.value.trim();
+            
+            if (message && currentSessionId) {
+                addMessage('You', message);
+                
+                socket.emit('message', {
+                    session_id: currentSessionId,
+                    content: message,
+                    language: document.getElementById('languageSelect').value
+                });
+                
+                input.value = '';
+            }
+        }
+
+        function addMessage(sender, content) {
+            const messages = document.getElementById('messages');
+            const messageDiv = document.createElement('div');
+            messageDiv.innerHTML = `<strong>${sender}:</strong> ${content}`;
+            messages.appendChild(messageDiv);
+            messages.scrollTop = messages.scrollHeight;
+        }
+
+        // Language switching
+        document.getElementById('languageSelect').addEventListener('change', (e) => {
+            if (currentSessionId) {
+                socket.emit('language_switch', {
+                    session_id: currentSessionId,
+                    language: e.target.value
+                });
+            }
+        });
+
+        // Enter key to send message
+        document.getElementById('messageInput').addEventListener('keypress', (e) => {
+            if (e.key === 'Enter') {
+                sendMessage();
+            }
+        });
+    </script>
+</body>
+</html>
+```
+
+## Advanced Usage Examples
+
+### Error Handling and Retry Logic
+
+```javascript
+class ChatAPIClient {
+    constructor(baseURL, userID) {
+        this.baseURL = baseURL;
+        this.userID = userID;
+        this.maxRetries = 3;
+        this.retryDelay = 1000; // 1 second
+    }
+
+    async makeRequest(endpoint, options = {}) {
+        const url = `${this.baseURL}${endpoint}`;
+        const config = {
+            ...options,
+            headers: {
+                'X-User-ID': this.userID,
+                'Content-Type': 'application/json',
+                ...options.headers
+            }
+        };
+
+        for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
+            try {
+                const response = await fetch(url, config);
+                
+                if (response.status === 429) {
+                    // Rate limited - wait and retry
+                    const retryAfter = response.headers.get('Retry-After') || this.retryDelay / 1000;
+                    await this.sleep(retryAfter * 1000);
+                    continue;
+                }
+                
+                if (!response.ok) {
+                    const error = await response.json();
+                    throw new Error(`API Error: ${error.message}`);
+                }
+                
+                return await response.json();
+                
+            } catch (error) {
+                if (attempt === this.maxRetries) {
+                    throw error;
+                }
+                
+                console.warn(`Attempt ${attempt} failed, retrying...`, error.message);
+                await this.sleep(this.retryDelay * attempt);
+            }
+        }
+    }
+
+    async createSession(language = 'python') {
+        return await this.makeRequest('/api/v1/chat/sessions', {
+            method: 'POST',
+            body: JSON.stringify({ language })
+        });
+    }
+
+    async getChatHistory(sessionId, page = 1, pageSize = 50) {
+        return await this.makeRequest(
+            `/api/v1/chat/sessions/${sessionId}/history?page=${page}&page_size=${pageSize}`
+        );
+    }
+
+    async switchLanguage(sessionId, language) {
+        return await this.makeRequest(`/api/v1/chat/sessions/${sessionId}/language`, {
+            method: 'PUT',
+            body: JSON.stringify({ language })
+        });
+    }
+
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+
+// Usage
+const client = new ChatAPIClient('http://localhost:5000', 'user-123');
+
+try {
+    const session = await client.createSession('python');
+    console.log('Session created:', session.session_id);
+    
+    const history = await client.getChatHistory(session.session_id);
+    console.log('Chat history:', history.messages);
+    
+    await client.switchLanguage(session.session_id, 'javascript');
+    console.log('Language switched to JavaScript');
+    
+} catch (error) {
+    console.error('API operation failed:', error.message);
+}
+```
+
+### Batch Operations
+
+```python
+import asyncio
+import aiohttp
+import json
+
+class AsyncChatClient:
+    def __init__(self, base_url, user_id):
+        self.base_url = base_url
+        self.user_id = user_id
+        self.headers = {
+            'X-User-ID': user_id,
+            'Content-Type': 'application/json'
+        }
+    
+    async def create_multiple_sessions(self, languages):
+        """Create multiple sessions concurrently."""
+        async with aiohttp.ClientSession() as session:
+            tasks = []
+            for language in languages:
+                task = self._create_session(session, language)
+                tasks.append(task)
+            
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            return results
+    
+    async def _create_session(self, session, language):
+        url = f"{self.base_url}/api/v1/chat/sessions"
+        data = {"language": language}
+        
+        async with session.post(url, headers=self.headers, json=data) as response:
+            if response.status == 201:
+                return await response.json()
+            else:
+                error = await response.json()
+                raise Exception(f"Failed to create {language} session: {error['message']}")
+
+# Usage
+async def main():
+    client = AsyncChatClient('http://localhost:5000', 'batch-user')
+    languages = ['python', 'javascript', 'java', 'cpp']
+    
+    sessions = await client.create_multiple_sessions(languages)
+    
+    for i, session in enumerate(sessions):
+        if isinstance(session, Exception):
+            print(f"Failed to create {languages[i]} session: {session}")
+        else:
+            print(f"Created {languages[i]} session: {session['session_id']}")
+
+# Run the async function
+asyncio.run(main())
+```
+
+## Implementation Notes
+
+- The API uses SQLite for testing and PostgreSQL for production
+- Redis is used for caching and session management
+- Rate limiting uses in-memory storage by default (configure Redis for production)
+- All timestamps are in ISO 8601 format (UTC)
+- UUIDs are used for all resource identifiers
+- The API supports both development (header-based) and production (token-based) authentication
+- WebSocket connections are managed using Flask-SocketIO
+- Streaming responses use Server-Sent Events (SSE) over WebSocket
+- All WebSocket events include session_id for proper message routing
+- Error handling includes automatic retry logic for transient failures
+- The system supports concurrent operations across multiple sessions

chat_agent/api/__init__.py

@@ -0,0 +1,12 @@
+"""Chat Agent API Components."""
+
+from .chat_routes import chat_bp
+from .middleware import create_limiter, setup_error_handlers, RequestLoggingMiddleware, create_auth_manager
+
+__all__ = [
+    'chat_bp',
+    'create_limiter',
+    'setup_error_handlers',
+    'RequestLoggingMiddleware',
+    'create_auth_manager'
+]

chat_agent/api/chat_routes.py

@@ -0,0 +1,642 @@
+"""Chat API routes for session management and chat history."""
+
+import logging
+from datetime import datetime
+from typing import Dict, Any, Optional
+
+from flask import Blueprint, request, jsonify, current_app, g
+from flask_limiter import Limiter
+from flask_limiter.util import get_remote_address
+import redis
+
+from ..services.session_manager import SessionManager, SessionManagerError, SessionNotFoundError, SessionExpiredError
+from ..services.chat_history import ChatHistoryManager, ChatHistoryError
+from ..services.language_context import LanguageContextManager, LanguageContextError
+from ..models.language_context import LanguageContext
+from ..models.base import db
+from .middleware import require_auth, validate_json_request, create_limiter
+
+
+logger = logging.getLogger(__name__)
+
+# Create blueprint
+chat_bp = Blueprint('chat', __name__, url_prefix='/api/v1/chat')
+
+# Initialize rate limiter (will be configured in app factory)
+limiter = create_limiter()
+
+
+class APIError(Exception):
+    """Base API error class."""
+    def __init__(self, message: str, status_code: int = 400, payload: Optional[Dict] = None):
+        super().__init__()
+        self.message = message
+        self.status_code = status_code
+        self.payload = payload
+
+
+def handle_api_error(error: APIError):
+    """Handle API errors and return JSON response."""
+    response = {'error': error.message}
+    if error.payload:
+        response.update(error.payload)
+    return jsonify(response), error.status_code
+
+
+def get_services():
+    """Get service instances from current app context."""
+    redis_client = None
+    redis_url = current_app.config.get('REDIS_URL')
+    
+    if redis_url and redis_url != 'None':
+        try:
+            redis_client = redis.from_url(redis_url)
+            # Test the connection
+            redis_client.ping()
+        except Exception as e:
+            logger.warning(f"Redis connection failed: {e}. Running without Redis cache.")
+            redis_client = None
+    else:
+        logger.info("Redis disabled in configuration. Running without Redis cache.")
+    
+    session_manager = SessionManager(redis_client, current_app.config.get('SESSION_TIMEOUT', 3600))
+    chat_history_manager = ChatHistoryManager(
+        redis_client,
+        current_app.config.get('MAX_CHAT_HISTORY', 20),
+        current_app.config.get('CONTEXT_WINDOW_SIZE', 10)
+    )
+    language_context_manager = LanguageContextManager()
+    
+    return session_manager, chat_history_manager, language_context_manager
+
+
+# Session Management Endpoints
+
+@chat_bp.route('/sessions', methods=['POST'])
+@limiter.limit("10 per minute")
+@require_auth
+@validate_json_request(['language'])
+def create_session():
+    """
+    Create a new chat session.
+    
+    Request body:
+    {
+        "language": "python",
+        "metadata": {"key": "value"}  // optional
+    }
+    """
+    try:
+        data = request.json_data
+        language = data['language']
+        metadata = data.get('metadata', {})
+        
+        # Validate language
+        if not LanguageContext.is_supported_language(language):
+            supported = LanguageContext.get_supported_languages()
+            raise APIError(f'Unsupported language: {language}. Supported: {", ".join(supported)}', 400)
+        
+        session_manager, _, language_context_manager = get_services()
+        
+        # Create session
+        session = session_manager.create_session(
+            user_id=request.user_id,
+            language=language,
+            session_metadata=metadata
+        )
+        
+        # Create language context
+        language_context_manager.create_context(session.id, language)
+        
+        logger.info(f"Created session {session.id} for user {request.user_id}")
+        
+        return jsonify({
+            'session_id': session.id,
+            'user_id': session.user_id,
+            'language': session.language,
+            'created_at': session.created_at.isoformat(),
+            'message_count': session.message_count,
+            'metadata': session.session_metadata
+        }), 201
+        
+    except (SessionManagerError, LanguageContextError) as e:
+        logger.error(f"Error creating session: {e}")
+        raise APIError(f'Failed to create session: {str(e)}', 500)
+    except APIError:
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error creating session: {e}")
+        raise APIError('Internal server error', 500)
+
+
+@chat_bp.route('/sessions/<session_id>', methods=['GET'])
+@limiter.limit("30 per minute")
+@require_auth
+def get_session(session_id: str):
+    """Get session information."""
+    try:
+        session_manager, _, _ = get_services()
+        
+        session = session_manager.get_session(session_id)
+        
+        # Check if user owns this session
+        if session.user_id != request.user_id:
+            raise APIError('Access denied', 403)
+        
+        return jsonify({
+            'session_id': session.id,
+            'user_id': session.user_id,
+            'language': session.language,
+            'created_at': session.created_at.isoformat(),
+            'last_active': session.last_active.isoformat(),
+            'message_count': session.message_count,
+            'is_active': session.is_active,
+            'metadata': session.session_metadata
+        })
+        
+    except SessionNotFoundError:
+        raise APIError('Session not found', 404)
+    except SessionExpiredError:
+        raise APIError('Session has expired', 410)
+    except SessionManagerError as e:
+        logger.error(f"Error getting session: {e}")
+        raise APIError(f'Failed to get session: {str(e)}', 500)
+    except APIError:
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error getting session: {e}")
+        raise APIError('Internal server error', 500)
+
+
+@chat_bp.route('/sessions/<session_id>', methods=['DELETE'])
+@limiter.limit("5 per minute")
+@require_auth
+def delete_session(session_id: str):
+    """Delete a chat session."""
+    try:
+        session_manager, chat_history_manager, _ = get_services()
+        
+        # Get session to check ownership
+        session = session_manager.get_session(session_id)
+        
+        # Check if user owns this session
+        if session.user_id != request.user_id:
+            raise APIError('Access denied', 403)
+        
+        # Clear chat history
+        message_count = chat_history_manager.clear_session_history(session_id)
+        
+        # Delete session
+        session_manager.delete_session(session_id)
+        
+        logger.info(f"Deleted session {session_id} with {message_count} messages")
+        
+        return jsonify({
+            'message': 'Session deleted successfully',
+            'session_id': session_id,
+            'messages_deleted': message_count
+        })
+        
+    except SessionNotFoundError:
+        raise APIError('Session not found', 404)
+    except (SessionManagerError, ChatHistoryError) as e:
+        logger.error(f"Error deleting session: {e}")
+        raise APIError(f'Failed to delete session: {str(e)}', 500)
+    except APIError:
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error deleting session: {e}")
+        raise APIError('Internal server error', 500)
+
+
+@chat_bp.route('/sessions', methods=['GET'])
+@limiter.limit("20 per minute")
+@require_auth
+def list_user_sessions():
+    """List all sessions for the authenticated user."""
+    try:
+        active_only = request.args.get('active_only', 'true').lower() == 'true'
+        
+        session_manager, _, _ = get_services()
+        
+        sessions = session_manager.get_user_sessions(request.user_id, active_only)
+        
+        session_list = []
+        for session in sessions:
+            session_list.append({
+                'session_id': session.id,
+                'language': session.language,
+                'created_at': session.created_at.isoformat(),
+                'last_active': session.last_active.isoformat(),
+                'message_count': session.message_count,
+                'is_active': session.is_active,
+                'metadata': session.session_metadata
+            })
+        
+        return jsonify({
+            'sessions': session_list,
+            'total_count': len(session_list),
+            'active_only': active_only
+        })
+        
+    except SessionManagerError as e:
+        logger.error(f"Error listing sessions: {e}")
+        raise APIError(f'Failed to list sessions: {str(e)}', 500)
+    except Exception as e:
+        logger.error(f"Unexpected error listing sessions: {e}")
+        raise APIError('Internal server error', 500)
+
+
+# Chat History Endpoints
+
+@chat_bp.route('/sessions/<session_id>/history', methods=['GET'])
+@limiter.limit("30 per minute")
+@require_auth
+def get_chat_history(session_id: str):
+    """Get chat history for a session."""
+    try:
+        # Validate session ownership
+        session_manager, chat_history_manager, _ = get_services()
+        session = session_manager.get_session(session_id)
+        
+        if session.user_id != request.user_id:
+            raise APIError('Access denied', 403)
+        
+        # Get pagination parameters
+        page = int(request.args.get('page', 1))
+        page_size = min(int(request.args.get('page_size', 50)), 100)  # Max 100 messages per page
+        recent_only = request.args.get('recent_only', 'false').lower() == 'true'
+        
+        if recent_only:
+            # Get recent messages for context
+            limit = min(int(request.args.get('limit', 10)), 50)  # Max 50 recent messages
+            messages = chat_history_manager.get_recent_history(session_id, limit)
+            total_count = len(messages)
+        else:
+            # Get paginated full history
+            messages = chat_history_manager.get_full_history(session_id, page, page_size)
+            total_count = chat_history_manager.get_message_count(session_id)
+        
+        message_list = []
+        for message in messages:
+            message_list.append({
+                'id': message.id,
+                'role': message.role,
+                'content': message.content,
+                'language': message.language,
+                'timestamp': message.timestamp.isoformat(),
+                'metadata': message.message_metadata
+            })
+        
+        response_data = {
+            'messages': message_list,
+            'session_id': session_id,
+            'total_count': total_count
+        }
+        
+        if not recent_only:
+            response_data.update({
+                'page': page,
+                'page_size': page_size,
+                'total_pages': (total_count + page_size - 1) // page_size
+            })
+        
+        return jsonify(response_data)
+        
+    except SessionNotFoundError:
+        raise APIError('Session not found', 404)
+    except SessionExpiredError:
+        raise APIError('Session has expired', 410)
+    except ChatHistoryError as e:
+        logger.error(f"Error getting chat history: {e}")
+        raise APIError(f'Failed to get chat history: {str(e)}', 500)
+    except APIError:
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error getting chat history: {e}")
+        raise APIError('Internal server error', 500)
+
+
+@chat_bp.route('/sessions/<session_id>/history/search', methods=['GET'])
+@limiter.limit("20 per minute")
+@require_auth
+def search_chat_history(session_id: str):
+    """Search chat history for a session."""
+    try:
+        query = request.args.get('q', '').strip()
+        if not query:
+            raise APIError('Search query is required', 400)
+        
+        if len(query) < 3:
+            raise APIError('Search query must be at least 3 characters', 400)
+        
+        # Validate session ownership
+        session_manager, chat_history_manager, _ = get_services()
+        session = session_manager.get_session(session_id)
+        
+        if session.user_id != request.user_id:
+            raise APIError('Access denied', 403)
+        
+        limit = min(int(request.args.get('limit', 20)), 50)  # Max 50 results
+        
+        messages = chat_history_manager.search_messages(session_id, query, limit)
+        
+        message_list = []
+        for message in messages:
+            message_list.append({
+                'id': message.id,
+                'role': message.role,
+                'content': message.content,
+                'language': message.language,
+                'timestamp': message.timestamp.isoformat(),
+                'metadata': message.message_metadata
+            })
+        
+        return jsonify({
+            'messages': message_list,
+            'session_id': session_id,
+            'query': query,
+            'result_count': len(message_list)
+        })
+        
+    except SessionNotFoundError:
+        raise APIError('Session not found', 404)
+    except SessionExpiredError:
+        raise APIError('Session has expired', 410)
+    except ChatHistoryError as e:
+        logger.error(f"Error searching chat history: {e}")
+        raise APIError(f'Failed to search chat history: {str(e)}', 500)
+    except APIError:
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error searching chat history: {e}")
+        raise APIError('Internal server error', 500)
+
+
+# Language Context Endpoints
+
+@chat_bp.route('/sessions/<session_id>/language', methods=['GET'])
+@limiter.limit("30 per minute")
+@require_auth
+def get_language_context(session_id: str):
+    """Get language context for a session."""
+    try:
+        # Validate session ownership
+        session_manager, _, language_context_manager = get_services()
+        session = session_manager.get_session(session_id)
+        
+        if session.user_id != request.user_id:
+            raise APIError('Access denied', 403)
+        
+        context = language_context_manager.get_context(session_id)
+        
+        return jsonify({
+            'session_id': session_id,
+            'language': context.language,
+            'prompt_template': context.get_prompt_template(),
+            'syntax_highlighting': context.get_syntax_highlighting(),
+            'language_info': context.get_language_info(),
+            'updated_at': context.updated_at.isoformat()
+        })
+        
+    except SessionNotFoundError:
+        raise APIError('Session not found', 404)
+    except SessionExpiredError:
+        raise APIError('Session has expired', 410)
+    except LanguageContextError as e:
+        logger.error(f"Error getting language context: {e}")
+        raise APIError(f'Failed to get language context: {str(e)}', 500)
+    except APIError:
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error getting language context: {e}")
+        raise APIError('Internal server error', 500)
+
+
+@chat_bp.route('/sessions/<session_id>/language', methods=['PUT'])
+@limiter.limit("10 per minute")
+@require_auth
+@validate_json_request(['language'])
+def update_language_context(session_id: str):
+    """Update language context for a session."""
+    try:
+        data = request.json_data
+        language = data['language']
+        
+        # Validate language
+        if not LanguageContext.is_supported_language(language):
+            supported = LanguageContext.get_supported_languages()
+            raise APIError(f'Unsupported language: {language}. Supported: {", ".join(supported)}', 400)
+        
+        # Validate session ownership
+        session_manager, _, language_context_manager = get_services()
+        session = session_manager.get_session(session_id)
+        
+        if session.user_id != request.user_id:
+            raise APIError('Access denied', 403)
+        
+        # Update language context
+        context = language_context_manager.set_language(session_id, language)
+        
+        # Update session language
+        session_manager.set_session_language(session_id, language)
+        
+        logger.info(f"Updated language to {language} for session {session_id}")
+        
+        return jsonify({
+            'session_id': session_id,
+            'language': context.language,
+            'prompt_template': context.get_prompt_template(),
+            'syntax_highlighting': context.get_syntax_highlighting(),
+            'language_info': context.get_language_info(),
+            'updated_at': context.updated_at.isoformat()
+        })
+        
+    except SessionNotFoundError:
+        raise APIError('Session not found', 404)
+    except SessionExpiredError:
+        raise APIError('Session has expired', 410)
+    except (SessionManagerError, LanguageContextError) as e:
+        logger.error(f"Error updating language context: {e}")
+        raise APIError(f'Failed to update language context: {str(e)}', 500)
+    except APIError:
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error updating language context: {e}")
+        raise APIError('Internal server error', 500)
+
+
+@chat_bp.route('/languages', methods=['GET'])
+@limiter.limit("50 per minute")
+def get_supported_languages():
+    """Get list of supported programming languages."""
+    try:
+        languages = LanguageContext.get_supported_languages()
+        language_names = LanguageContext.get_language_display_names()
+        
+        language_list = []
+        for lang_code in languages:
+            lang_info = LanguageContext.SUPPORTED_LANGUAGES[lang_code]
+            language_list.append({
+                'code': lang_code,
+                'name': lang_info['name'],
+                'syntax_highlighting': lang_info['syntax_highlighting'],
+                'file_extensions': lang_info['file_extensions']
+            })
+        
+        return jsonify({
+            'languages': language_list,
+            'default_language': 'python',
+            'total_count': len(language_list)
+        })
+        
+    except Exception as e:
+        logger.error(f"Unexpected error getting supported languages: {e}")
+        raise APIError('Internal server error', 500)
+
+
+# Message Processing Endpoint
+
+@chat_bp.route('/sessions/<session_id>/message', methods=['POST'])
+@limiter.limit("30 per minute")
+@require_auth
+@validate_json_request(['content'])
+def send_message(session_id: str):
+    """Send a message to the chat agent and get a response."""
+    try:
+        data = request.json_data
+        content = data['content'].strip()
+        language = data.get('language')  # Optional language override
+        
+        if not content:
+            raise APIError('Message content cannot be empty', 400)
+        
+        if len(content) > 5000:  # Reasonable message length limit
+            raise APIError('Message too long (max 5000 characters)', 400)
+        
+        # Get services
+        session_manager, chat_history_manager, language_context_manager = get_services()
+        
+        # Validate session ownership
+        session = session_manager.get_session(session_id)
+        if session.user_id != request.user_id:
+            raise APIError('Access denied', 403)
+        
+        # Initialize chat agent
+        from ..services.groq_client import GroqClient
+        from ..services.chat_agent import ChatAgent
+        from ..services.programming_assistance import ProgrammingAssistanceService
+        
+        groq_client = GroqClient()
+        programming_assistance_service = ProgrammingAssistanceService()
+        
+        chat_agent = ChatAgent(
+            groq_client=groq_client,
+            language_context_manager=language_context_manager,
+            session_manager=session_manager,
+            chat_history_manager=chat_history_manager,
+            programming_assistance_service=programming_assistance_service
+        )
+        
+        # Process the message
+        result = chat_agent.process_message(session_id, content, language)
+        
+        logger.info(f"Processed message for session {session_id}, response length: {len(result['response'])}")
+        
+        return jsonify({
+            'response': result['response'],
+            'message_id': result['message_id'],
+            'session_id': session_id,
+            'language': result['language'],
+            'processing_time': result['processing_time'],
+            'timestamp': result['timestamp']
+        })
+        
+    except SessionNotFoundError:
+        raise APIError('Session not found', 404)
+    except SessionExpiredError:
+        raise APIError('Session has expired', 410)
+    except ChatAgentError as e:
+        logger.error(f"Chat agent error: {e}")
+        raise APIError(f'Failed to process message: {str(e)}', 500)
+    except APIError:
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error processing message: {e}")
+        raise APIError('Internal server error', 500)
+
+
+# Health Check Endpoint
+
+@chat_bp.route('/health', methods=['GET'])
+def health_check():
+    """Health check endpoint for monitoring."""
+    try:
+        # Check database connection
+        from sqlalchemy import text
+        db.session.execute(text('SELECT 1'))
+        
+        # Check Redis connection (if configured)
+        redis_status = "disabled"
+        redis_url = current_app.config.get('REDIS_URL')
+        if redis_url and redis_url != 'None':
+            try:
+                redis_client = redis.from_url(redis_url)
+                redis_client.ping()
+                redis_status = "connected"
+            except Exception:
+                redis_status = "disconnected"
+        else:
+            redis_status = "disabled"
+        
+        return jsonify({
+            'status': 'healthy',
+            'timestamp': datetime.utcnow().isoformat(),
+            'services': {
+                'database': 'connected',
+                'redis': redis_status
+            }
+        })
+        
+    except Exception as e:
+        logger.error(f"Health check failed: {e}")
+        return jsonify({
+            'status': 'unhealthy',
+            'timestamp': datetime.utcnow().isoformat(),
+            'error': str(e)
+        }), 503
+
+
+# Error handlers
+@chat_bp.errorhandler(APIError)
+def handle_api_error_handler(error):
+    """Handle APIError exceptions."""
+    return handle_api_error(error)
+
+
+@chat_bp.errorhandler(400)
+def handle_bad_request(error):
+    """Handle bad request errors."""
+    return jsonify({'error': 'Bad request'}), 400
+
+
+@chat_bp.errorhandler(404)
+def handle_not_found(error):
+    """Handle not found errors."""
+    return jsonify({'error': 'Not found'}), 404
+
+
+@chat_bp.errorhandler(429)
+def handle_rate_limit_exceeded(error):
+    """Handle rate limit exceeded errors."""
+    return jsonify({
+        'error': 'Rate limit exceeded',
+        'message': 'Too many requests. Please try again later.'
+    }), 429
+
+
+@chat_bp.errorhandler(500)
+def handle_internal_error(error):
+    """Handle internal server errors."""
+    logger.error(f"Internal server error: {error}")
+    return jsonify({'error': 'Internal server error'}), 500

chat_agent/api/health.py

@@ -0,0 +1,243 @@
+"""Health check endpoints for monitoring and load balancing."""
+
+import time
+import psutil
+from datetime import datetime
+from flask import Blueprint, jsonify, current_app
+import redis
+import psycopg2
+from sqlalchemy import text
+
+from chat_agent.models.base import db
+from chat_agent.utils.error_handler import get_error_handler
+
+health_bp = Blueprint('health', __name__, url_prefix='/health')
+
+
+def check_database():
+    """Check database connectivity and basic operations."""
+    try:
+        # Test basic database connection
+        result = db.session.execute(text('SELECT 1'))
+        result.fetchone()
+        
+        # Test if migrations table exists (indicates proper setup)
+        result = db.session.execute(text(
+            "SELECT COUNT(*) FROM information_schema.tables WHERE table_name = 'schema_migrations'"
+        ))
+        migrations_table_exists = result.fetchone()[0] > 0
+        
+        return {
+            'status': 'healthy',
+            'connection': 'ok',
+            'migrations_table': 'exists' if migrations_table_exists else 'missing',
+            'response_time_ms': 0  # Will be calculated by caller
+        }
+    except Exception as e:
+        return {
+            'status': 'unhealthy',
+            'error': str(e),
+            'connection': 'failed'
+        }
+
+
+def check_redis():
+    """Check Redis connectivity and basic operations."""
+    redis_url = current_app.config.get('REDIS_URL')
+    if not redis_url or redis_url == 'None':
+        return {
+            'status': 'disabled',
+            'message': 'Redis is disabled in configuration'
+        }
+    
+    try:
+        redis_client = redis.from_url(redis_url)
+        
+        # Test basic operations
+        start_time = time.time()
+        redis_client.ping()
+        response_time = (time.time() - start_time) * 1000
+        
+        # Test set/get operation
+        test_key = 'health_check_test'
+        redis_client.set(test_key, 'test_value', ex=10)
+        value = redis_client.get(test_key)
+        redis_client.delete(test_key)
+        
+        return {
+            'status': 'healthy',
+            'connection': 'ok',
+            'response_time_ms': round(response_time, 2),
+            'operations': 'ok' if value == b'test_value' else 'failed'
+        }
+    except Exception as e:
+        return {
+            'status': 'unhealthy',
+            'error': str(e),
+            'connection': 'failed'
+        }
+
+
+def check_groq_api():
+    """Check Groq API configuration and basic connectivity."""
+    groq_api_key = current_app.config.get('GROQ_API_KEY')
+    
+    if not groq_api_key:
+        return {
+            'status': 'unhealthy',
+            'error': 'GROQ_API_KEY not configured'
+        }
+    
+    # Basic configuration check
+    return {
+        'status': 'configured',
+        'api_key_present': bool(groq_api_key),
+        'model': current_app.config.get('GROQ_MODEL', 'not_configured'),
+        'note': 'API connectivity not tested in health check to avoid quota usage'
+    }
+
+
+def get_system_metrics():
+    """Get basic system metrics."""
+    try:
+        return {
+            'cpu_percent': psutil.cpu_percent(interval=1),
+            'memory_percent': psutil.virtual_memory().percent,
+            'disk_percent': psutil.disk_usage('/').percent,
+            'load_average': psutil.getloadavg()[0] if hasattr(psutil, 'getloadavg') else None
+        }
+    except Exception as e:
+        return {
+            'error': f'Failed to get system metrics: {str(e)}'
+        }
+
+
+@health_bp.route('/')
+@health_bp.route('/basic')
+def basic_health():
+    """Basic health check endpoint for load balancers."""
+    return jsonify({
+        'status': 'healthy',
+        'timestamp': datetime.utcnow().isoformat(),
+        'service': 'chat-agent',
+        'version': '1.0.0'
+    }), 200
+
+
+@health_bp.route('/detailed')
+def detailed_health():
+    """Detailed health check with all dependencies."""
+    start_time = time.time()
+    
+    # Check all components
+    db_start = time.time()
+    database_health = check_database()
+    database_health['response_time_ms'] = round((time.time() - db_start) * 1000, 2)
+    
+    redis_health = check_redis()
+    groq_health = check_groq_api()
+    system_metrics = get_system_metrics()
+    
+    # Determine overall status
+    overall_status = 'healthy'
+    if database_health['status'] == 'unhealthy':
+        overall_status = 'unhealthy'
+    elif redis_health['status'] == 'unhealthy':
+        overall_status = 'degraded'  # Redis failure is not critical
+    elif groq_health['status'] == 'unhealthy':
+        overall_status = 'degraded'  # Can still serve static content
+    
+    response = {
+        'status': overall_status,
+        'timestamp': datetime.utcnow().isoformat(),
+        'service': 'chat-agent',
+        'version': '1.0.0',
+        'uptime_seconds': round(time.time() - start_time, 2),
+        'components': {
+            'database': database_health,
+            'redis': redis_health,
+            'groq_api': groq_health
+        },
+        'system': system_metrics,
+        'config': {
+            'environment': current_app.config.get('FLASK_ENV', 'unknown'),
+            'debug': current_app.config.get('DEBUG', False),
+            'default_language': current_app.config.get('DEFAULT_LANGUAGE', 'python')
+        }
+    }
+    
+    # Return appropriate HTTP status code
+    status_code = 200
+    if overall_status == 'unhealthy':
+        status_code = 503
+    elif overall_status == 'degraded':
+        status_code = 200  # Still functional
+    
+    return jsonify(response), status_code
+
+
+@health_bp.route('/ready')
+def readiness():
+    """Readiness probe for Kubernetes/container orchestration."""
+    # Check critical dependencies only
+    db_health = check_database()
+    
+    if db_health['status'] == 'healthy':
+        return jsonify({
+            'status': 'ready',
+            'timestamp': datetime.utcnow().isoformat(),
+            'database': 'connected'
+        }), 200
+    else:
+        return jsonify({
+            'status': 'not_ready',
+            'timestamp': datetime.utcnow().isoformat(),
+            'database': 'disconnected',
+            'error': db_health.get('error', 'Database check failed')
+        }), 503
+
+
+@health_bp.route('/live')
+def liveness():
+    """Liveness probe for Kubernetes/container orchestration."""
+    # Simple check that the application is running
+    return jsonify({
+        'status': 'alive',
+        'timestamp': datetime.utcnow().isoformat(),
+        'service': 'chat-agent'
+    }), 200
+
+
+@health_bp.route('/metrics')
+def metrics():
+    """Basic metrics endpoint for monitoring systems."""
+    system_metrics = get_system_metrics()
+    
+    # Add application-specific metrics
+    app_metrics = {
+        'active_sessions': 0,  # TODO: Implement session counting
+        'total_messages': 0,   # TODO: Implement message counting
+        'cache_hit_rate': 0.0  # TODO: Implement cache metrics
+    }
+    
+    return jsonify({
+        'timestamp': datetime.utcnow().isoformat(),
+        'system': system_metrics,
+        'application': app_metrics
+    }), 200
+
+
+# Error handler for health check blueprint
+@health_bp.errorhandler(Exception)
+def handle_health_error(error):
+    """Handle errors in health check endpoints."""
+    error_handler = get_error_handler()
+    if error_handler:
+        error_handler.handle_error(error, context="health_check")
+    
+    return jsonify({
+        'status': 'error',
+        'timestamp': datetime.utcnow().isoformat(),
+        'error': 'Health check failed',
+        'message': str(error)
+    }), 500

chat_agent/api/middleware.py

@@ -0,0 +1,402 @@
+"""Middleware for authentication, authorization, and rate limiting."""
+
+import logging
+import time
+from functools import wraps
+from typing import Dict, Any, Optional
+
+from flask import request, jsonify, current_app, g
+from flask_limiter import Limiter
+from flask_limiter.util import get_remote_address
+import redis
+import jwt
+from datetime import datetime, timedelta
+
+logger = logging.getLogger(__name__)
+
+
+class AuthenticationError(Exception):
+    """Authentication related errors."""
+    pass
+
+
+class AuthorizationError(Exception):
+    """Authorization related errors."""
+    pass
+
+
+class RateLimitError(Exception):
+    """Rate limiting related errors."""
+    pass
+
+
+def create_limiter(app=None):
+    """Create and configure rate limiter."""
+    limiter = Limiter(
+        key_func=get_remote_address,
+        default_limits=["200 per day", "50 per hour"],
+        storage_uri=None  # Will be set from app config
+    )
+    
+    if app:
+        limiter.init_app(app)
+    
+    return limiter
+
+
+class SimpleAuthManager:
+    """
+    Simple authentication manager for development/testing.
+    In production, this would be replaced with proper JWT/OAuth implementation.
+    """
+    
+    def __init__(self, redis_client: Optional[redis.Redis] = None):
+        """Initialize auth manager."""
+        self.redis_client = redis_client
+        self.session_prefix = "auth_session:"
+        self.user_prefix = "user:"
+        
+    def create_session_token(self, user_id: str, expires_in: int = 3600) -> str:
+        """
+        Create a simple session token for a user.
+        
+        Args:
+            user_id: User identifier
+            expires_in: Token expiration in seconds
+            
+        Returns:
+            str: Session token
+        """
+        try:
+            # Create a simple token (in production, use proper JWT)
+            token_data = {
+                'user_id': user_id,
+                'created_at': time.time(),
+                'expires_at': time.time() + expires_in
+            }
+            
+            # For simplicity, use user_id as token (in production, use secure random token)
+            token = f"session_{user_id}_{int(time.time())}"
+            
+            if self.redis_client:
+                # Store token in Redis
+                self.redis_client.setex(
+                    f"{self.session_prefix}{token}",
+                    expires_in,
+                    user_id
+                )
+            
+            return token
+            
+        except Exception as e:
+            logger.error(f"Error creating session token: {e}")
+            raise AuthenticationError(f"Failed to create session token: {e}")
+    
+    def validate_session_token(self, token: str) -> Optional[str]:
+        """
+        Validate a session token and return user_id if valid.
+        
+        Args:
+            token: Session token to validate
+            
+        Returns:
+            str: User ID if token is valid, None otherwise
+        """
+        try:
+            if not token:
+                return None
+            
+            if self.redis_client:
+                # Check Redis for token
+                user_id = self.redis_client.get(f"{self.session_prefix}{token}")
+                if user_id:
+                    return user_id.decode('utf-8')
+            
+            # Fallback: simple token validation (for development)
+            if token.startswith('session_'):
+                parts = token.split('_')
+                if len(parts) >= 2:
+                    return parts[1]  # Return user_id part
+            
+            return None
+            
+        except Exception as e:
+            logger.error(f"Error validating session token: {e}")
+            return None
+    
+    def revoke_session_token(self, token: str) -> bool:
+        """
+        Revoke a session token.
+        
+        Args:
+            token: Session token to revoke
+            
+        Returns:
+            bool: True if token was revoked, False otherwise
+        """
+        try:
+            if self.redis_client:
+                result = self.redis_client.delete(f"{self.session_prefix}{token}")
+                return result > 0
+            
+            return True  # For development, always return True
+            
+        except Exception as e:
+            logger.error(f"Error revoking session token: {e}")
+            return False
+
+
+def require_auth(f):
+    """
+    Authentication decorator for API endpoints.
+    Supports both header-based authentication and session tokens.
+    """
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        try:
+            # Check for session token first
+            auth_header = request.headers.get('Authorization')
+            if auth_header and auth_header.startswith('Bearer '):
+                token = auth_header.split(' ')[1]
+                
+                # Get auth manager from app context
+                redis_client = redis.from_url(current_app.config['REDIS_URL'])
+                auth_manager = SimpleAuthManager(redis_client)
+                
+                user_id = auth_manager.validate_session_token(token)
+                if user_id:
+                    g.user_id = user_id
+                    request.user_id = user_id
+                    return f(*args, **kwargs)
+            
+            # Fallback to simple header-based auth (for development)
+            user_id = request.headers.get('X-User-ID')
+            if user_id:
+                g.user_id = user_id
+                request.user_id = user_id
+                return f(*args, **kwargs)
+            
+            # No valid authentication found
+            return jsonify({
+                'error': 'Authentication required',
+                'message': 'Please provide a valid Authorization header or X-User-ID header'
+            }), 401
+            
+        except Exception as e:
+            logger.error(f"Authentication error: {e}")
+            return jsonify({
+                'error': 'Authentication failed',
+                'message': 'Invalid authentication credentials'
+            }), 401
+    
+    return decorated_function
+
+
+def require_session_ownership(f):
+    """
+    Authorization decorator to ensure user owns the session.
+    Must be used after require_auth.
+    """
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        try:
+            session_id = kwargs.get('session_id') or request.view_args.get('session_id')
+            if not session_id:
+                return jsonify({
+                    'error': 'Session ID required',
+                    'message': 'Session ID must be provided in the URL'
+                }), 400
+            
+            user_id = getattr(g, 'user_id', None) or getattr(request, 'user_id', None)
+            if not user_id:
+                return jsonify({
+                    'error': 'User not authenticated',
+                    'message': 'User authentication required'
+                }), 401
+            
+            # Import here to avoid circular imports
+            from ..services.session_manager import SessionManager, SessionNotFoundError
+            
+            redis_client = redis.from_url(current_app.config['REDIS_URL'])
+            session_manager = SessionManager(redis_client)
+            
+            try:
+                session = session_manager.get_session(session_id)
+                if session.user_id != user_id:
+                    return jsonify({
+                        'error': 'Access denied',
+                        'message': 'You do not have permission to access this session'
+                    }), 403
+                
+                # Store session in request context for use in endpoint
+                g.session = session
+                request.session = session
+                
+            except SessionNotFoundError:
+                return jsonify({
+                    'error': 'Session not found',
+                    'message': f'Session {session_id} does not exist'
+                }), 404
+            
+            return f(*args, **kwargs)
+            
+        except Exception as e:
+            logger.error(f"Authorization error: {e}")
+            return jsonify({
+                'error': 'Authorization failed',
+                'message': 'Failed to verify session ownership'
+            }), 500
+    
+    return decorated_function
+
+
+def validate_json_request(required_fields: list = None, optional_fields: list = None):
+    """
+    Decorator to validate JSON request data.
+    
+    Args:
+        required_fields: List of required field names
+        optional_fields: List of optional field names (for documentation)
+    """
+    def decorator(f):
+        @wraps(f)
+        def decorated_function(*args, **kwargs):
+            if not request.is_json:
+                return jsonify({
+                    'error': 'Invalid content type',
+                    'message': 'Request must be JSON'
+                }), 400
+            
+            try:
+                data = request.get_json()
+            except Exception as e:
+                return jsonify({
+                    'error': 'Invalid JSON',
+                    'message': f'Failed to parse JSON: {str(e)}'
+                }), 400
+            
+            if not data:
+                return jsonify({
+                    'error': 'Empty request body',
+                    'message': 'Request body cannot be empty'
+                }), 400
+            
+            if required_fields:
+                missing_fields = [field for field in required_fields if field not in data]
+                if missing_fields:
+                    return jsonify({
+                        'error': 'Missing required fields',
+                        'message': f'Required fields: {", ".join(missing_fields)}',
+                        'missing_fields': missing_fields
+                    }), 400
+            
+            # Store validated data in request context
+            g.json_data = data
+            request.json_data = data
+            
+            return f(*args, **kwargs)
+        
+        return decorated_function
+    return decorator
+
+
+def handle_rate_limit_exceeded(e):
+    """Handle rate limit exceeded errors."""
+    return jsonify({
+        'error': 'Rate limit exceeded',
+        'message': 'Too many requests. Please try again later.',
+        'retry_after': getattr(e, 'retry_after', None)
+    }), 429
+
+
+def setup_error_handlers(app):
+    """Setup error handlers for the application."""
+    
+    @app.errorhandler(AuthenticationError)
+    def handle_auth_error(error):
+        return jsonify({
+            'error': 'Authentication failed',
+            'message': str(error)
+        }), 401
+    
+    @app.errorhandler(AuthorizationError)
+    def handle_authz_error(error):
+        return jsonify({
+            'error': 'Authorization failed',
+            'message': str(error)
+        }), 403
+    
+    @app.errorhandler(429)
+    def handle_rate_limit(error):
+        return handle_rate_limit_exceeded(error)
+    
+    @app.errorhandler(400)
+    def handle_bad_request(error):
+        return jsonify({
+            'error': 'Bad request',
+            'message': 'The request could not be understood by the server'
+        }), 400
+    
+    @app.errorhandler(404)
+    def handle_not_found(error):
+        return jsonify({
+            'error': 'Not found',
+            'message': 'The requested resource was not found'
+        }), 404
+    
+    @app.errorhandler(500)
+    def handle_internal_error(error):
+        logger.error(f"Internal server error: {error}")
+        return jsonify({
+            'error': 'Internal server error',
+            'message': 'An unexpected error occurred'
+        }), 500
+
+
+class RequestLoggingMiddleware:
+    """Middleware for logging API requests."""
+    
+    def __init__(self, app=None):
+        self.app = app
+        if app:
+            self.init_app(app)
+    
+    def init_app(self, app):
+        """Initialize the middleware with the Flask app."""
+        app.before_request(self.log_request)
+        app.after_request(self.log_response)
+    
+    def log_request(self):
+        """Log incoming requests."""
+        if request.endpoint and not request.endpoint.startswith('static'):
+            logger.info(f"API Request: {request.method} {request.path} from {request.remote_addr}")
+            
+            # Log request data for debugging (be careful with sensitive data)
+            if request.is_json and current_app.debug:
+                try:
+                    data = request.get_json()
+                    # Remove sensitive fields before logging
+                    safe_data = {k: v for k, v in data.items() if k not in ['password', 'token', 'secret']}
+                    logger.debug(f"Request data: {safe_data}")
+                except:
+                    pass
+    
+    def log_response(self, response):
+        """Log outgoing responses."""
+        if request.endpoint and not request.endpoint.startswith('static'):
+            logger.info(f"API Response: {response.status_code} for {request.method} {request.path}")
+        
+        return response
+
+
+def create_auth_manager(redis_client: redis.Redis) -> SimpleAuthManager:
+    """
+    Factory function to create an authentication manager.
+    
+    Args:
+        redis_client: Redis client instance
+        
+    Returns:
+        SimpleAuthManager: Configured auth manager instance
+    """
+    return SimpleAuthManager(redis_client)

chat_agent/api/performance_routes.py

@@ -0,0 +1,441 @@
+"""
+Performance monitoring API routes.
+
+This module provides endpoints for monitoring system performance,
+connection pool status, cache statistics, and other performance metrics.
+"""
+
+import logging
+from datetime import datetime
+from typing import Dict, Any
+
+from flask import Blueprint, jsonify, current_app
+from flask_limiter import Limiter
+
+from ..utils.connection_pool import get_connection_pool_manager
+from ..services.cache_service import get_cache_service
+from .middleware import require_auth, create_limiter
+from ..utils.response_optimization import cache_response, compress_response
+
+logger = logging.getLogger(__name__)
+
+# Create blueprint
+performance_bp = Blueprint('performance', __name__, url_prefix='/api/v1/performance')
+
+# Initialize rate limiter
+limiter = create_limiter()
+
+
+@performance_bp.route('/status', methods=['GET'])
+@limiter.limit("30 per minute")
+@cache_response(max_age=60, cache_type='private')  # Cache for 1 minute
+@compress_response
+def get_performance_status():
+    """
+    Get overall system performance status.
+    
+    Returns:
+        JSON response with performance metrics
+    """
+    try:
+        status = {
+            'timestamp': datetime.utcnow().isoformat(),
+            'status': 'healthy',
+            'services': {}
+        }
+        
+        # Database connection pool status
+        connection_pool_manager = get_connection_pool_manager()
+        if connection_pool_manager:
+            pool_status = connection_pool_manager.get_status()
+            status['services']['database'] = {
+                'status': 'connected',
+                'pool_stats': pool_status['database']
+            }
+            
+            if pool_status['redis']:
+                status['services']['redis'] = {
+                    'status': 'connected' if pool_status['redis']['healthy'] else 'unhealthy',
+                    'pool_stats': pool_status['redis']
+                }
+            else:
+                status['services']['redis'] = {
+                    'status': 'disabled'
+                }
+        else:
+            status['services']['database'] = {'status': 'no_pool_manager'}
+            status['services']['redis'] = {'status': 'no_pool_manager'}
+        
+        # Cache service status
+        cache_service = get_cache_service()
+        if cache_service:
+            cache_stats = cache_service.get_cache_stats()
+            status['services']['cache'] = {
+                'status': 'enabled' if cache_stats['redis_enabled'] else 'disabled',
+                'stats': cache_stats
+            }
+        else:
+            status['services']['cache'] = {'status': 'not_initialized'}
+        
+        # Application configuration
+        status['configuration'] = {
+            'compression_enabled': current_app.config.get('ENABLE_COMPRESSION', False),
+            'caching_enabled': current_app.config.get('ENABLE_CACHING', False),
+            'performance_monitoring': current_app.config.get('ENABLE_PERFORMANCE_MONITORING', False),
+            'db_pool_size': current_app.config.get('DB_POOL_SIZE', 10),
+            'redis_max_connections': current_app.config.get('REDIS_MAX_CONNECTIONS', 20)
+        }
+        
+        return jsonify(status)
+        
+    except Exception as e:
+        logger.error(f"Error getting performance status: {e}")
+        return jsonify({
+            'timestamp': datetime.utcnow().isoformat(),
+            'status': 'error',
+            'error': str(e)
+        }), 500
+
+
+@performance_bp.route('/database', methods=['GET'])
+@limiter.limit("20 per minute")
+@require_auth
+@cache_response(max_age=30, cache_type='private')
+@compress_response
+def get_database_performance():
+    """
+    Get database performance metrics.
+    
+    Returns:
+        JSON response with database performance data
+    """
+    try:
+        connection_pool_manager = get_connection_pool_manager()
+        
+        if not connection_pool_manager:
+            return jsonify({
+                'error': 'Connection pool manager not available'
+            }), 503
+        
+        # Get database pool status
+        pool_status = connection_pool_manager.get_status()
+        database_stats = pool_status['database']
+        
+        # Calculate pool utilization
+        total_connections = database_stats['pool_size'] + database_stats['overflow']
+        active_connections = database_stats['checked_out']
+        utilization = (active_connections / total_connections * 100) if total_connections > 0 else 0
+        
+        response_data = {
+            'timestamp': datetime.utcnow().isoformat(),
+            'pool_stats': database_stats,
+            'utilization': {
+                'active_connections': active_connections,
+                'total_connections': total_connections,
+                'utilization_percent': round(utilization, 2)
+            },
+            'health': {
+                'status': 'healthy' if utilization < 80 else 'warning' if utilization < 95 else 'critical',
+                'invalid_connections': database_stats['invalid']
+            }
+        }
+        
+        return jsonify(response_data)
+        
+    except Exception as e:
+        logger.error(f"Error getting database performance: {e}")
+        return jsonify({
+            'timestamp': datetime.utcnow().isoformat(),
+            'error': str(e)
+        }), 500
+
+
+@performance_bp.route('/redis', methods=['GET'])
+@limiter.limit("20 per minute")
+@require_auth
+@cache_response(max_age=30, cache_type='private')
+@compress_response
+def get_redis_performance():
+    """
+    Get Redis performance metrics.
+    
+    Returns:
+        JSON response with Redis performance data
+    """
+    try:
+        connection_pool_manager = get_connection_pool_manager()
+        
+        if not connection_pool_manager:
+            return jsonify({
+                'error': 'Connection pool manager not available'
+            }), 503
+        
+        redis_client = connection_pool_manager.get_redis_client()
+        
+        if not redis_client:
+            return jsonify({
+                'status': 'disabled',
+                'message': 'Redis is not configured'
+            })
+        
+        # Get Redis pool status
+        pool_status = connection_pool_manager.get_status()
+        redis_stats = pool_status['redis']
+        
+        # Get Redis server info
+        try:
+            redis_info = redis_client.info()
+            server_stats = {
+                'version': redis_info.get('redis_version', 'unknown'),
+                'uptime_seconds': redis_info.get('uptime_in_seconds', 0),
+                'connected_clients': redis_info.get('connected_clients', 0),
+                'used_memory': redis_info.get('used_memory_human', 'unknown'),
+                'keyspace_hits': redis_info.get('keyspace_hits', 0),
+                'keyspace_misses': redis_info.get('keyspace_misses', 0),
+                'total_commands_processed': redis_info.get('total_commands_processed', 0)
+            }
+            
+            # Calculate hit rate
+            total_keyspace_ops = server_stats['keyspace_hits'] + server_stats['keyspace_misses']
+            hit_rate = (server_stats['keyspace_hits'] / total_keyspace_ops * 100) if total_keyspace_ops > 0 else 0
+            
+        except Exception as e:
+            logger.warning(f"Failed to get Redis server info: {e}")
+            server_stats = {'error': 'Failed to get server info'}
+            hit_rate = 0
+        
+        response_data = {
+            'timestamp': datetime.utcnow().isoformat(),
+            'pool_stats': redis_stats,
+            'server_stats': server_stats,
+            'performance': {
+                'hit_rate_percent': round(hit_rate, 2),
+                'health_status': redis_stats.get('healthy', False)
+            }
+        }
+        
+        return jsonify(response_data)
+        
+    except Exception as e:
+        logger.error(f"Error getting Redis performance: {e}")
+        return jsonify({
+            'timestamp': datetime.utcnow().isoformat(),
+            'error': str(e)
+        }), 500
+
+
+@performance_bp.route('/cache', methods=['GET'])
+@limiter.limit("20 per minute")
+@require_auth
+@cache_response(max_age=60, cache_type='private')
+@compress_response
+def get_cache_performance():
+    """
+    Get cache performance metrics.
+    
+    Returns:
+        JSON response with cache performance data
+    """
+    try:
+        cache_service = get_cache_service()
+        
+        if not cache_service:
+            return jsonify({
+                'status': 'not_initialized',
+                'message': 'Cache service not initialized'
+            })
+        
+        cache_stats = cache_service.get_cache_stats()
+        
+        # Add performance analysis
+        performance_analysis = {
+            'efficiency': 'excellent' if cache_stats['hit_rate_percent'] >= 80 else
+                         'good' if cache_stats['hit_rate_percent'] >= 60 else
+                         'fair' if cache_stats['hit_rate_percent'] >= 40 else 'poor',
+            'recommendations': []
+        }
+        
+        if cache_stats['hit_rate_percent'] < 60:
+            performance_analysis['recommendations'].append('Consider increasing cache TTL')
+            performance_analysis['recommendations'].append('Review cache key strategies')
+        
+        if cache_stats['cache_errors'] > 0:
+            performance_analysis['recommendations'].append('Investigate cache errors')
+        
+        response_data = {
+            'timestamp': datetime.utcnow().isoformat(),
+            'cache_stats': cache_stats,
+            'performance_analysis': performance_analysis
+        }
+        
+        return jsonify(response_data)
+        
+    except Exception as e:
+        logger.error(f"Error getting cache performance: {e}")
+        return jsonify({
+            'timestamp': datetime.utcnow().isoformat(),
+            'error': str(e)
+        }), 500
+
+
+@performance_bp.route('/metrics', methods=['GET'])
+@limiter.limit("10 per minute")
+@require_auth
+@cache_response(max_age=120, cache_type='private')  # Cache for 2 minutes
+@compress_response
+def get_comprehensive_metrics():
+    """
+    Get comprehensive performance metrics.
+    
+    Returns:
+        JSON response with all performance metrics
+    """
+    try:
+        metrics = {
+            'timestamp': datetime.utcnow().isoformat(),
+            'system': {},
+            'database': {},
+            'redis': {},
+            'cache': {},
+            'application': {}
+        }
+        
+        # System metrics
+        try:
+            import psutil
+            import os
+            
+            process = psutil.Process(os.getpid())
+            cpu_percent = process.cpu_percent()
+            memory_info = process.memory_info()
+            
+            metrics['system'] = {
+                'cpu_percent': cpu_percent,
+                'memory_rss_mb': round(memory_info.rss / 1024 / 1024, 2),
+                'memory_vms_mb': round(memory_info.vms / 1024 / 1024, 2),
+                'num_threads': process.num_threads(),
+                'num_fds': process.num_fds() if hasattr(process, 'num_fds') else 'N/A'
+            }
+        except ImportError:
+            metrics['system'] = {'error': 'psutil not available'}
+        except Exception as e:
+            metrics['system'] = {'error': str(e)}
+        
+        # Database metrics
+        connection_pool_manager = get_connection_pool_manager()
+        if connection_pool_manager:
+            pool_status = connection_pool_manager.get_status()
+            metrics['database'] = pool_status['database']
+            metrics['redis'] = pool_status['redis'] or {'status': 'disabled'}
+        
+        # Cache metrics
+        cache_service = get_cache_service()
+        if cache_service:
+            metrics['cache'] = cache_service.get_cache_stats()
+        
+        # Application metrics
+        metrics['application'] = {
+            'config': {
+                'compression_enabled': current_app.config.get('ENABLE_COMPRESSION', False),
+                'caching_enabled': current_app.config.get('ENABLE_CACHING', False),
+                'debug_mode': current_app.config.get('DEBUG', False)
+            },
+            'flask': {
+                'testing': current_app.testing,
+                'debug': current_app.debug
+            }
+        }
+        
+        return jsonify(metrics)
+        
+    except Exception as e:
+        logger.error(f"Error getting comprehensive metrics: {e}")
+        return jsonify({
+            'timestamp': datetime.utcnow().isoformat(),
+            'error': str(e)
+        }), 500
+
+
+@performance_bp.route('/health', methods=['GET'])
+@limiter.limit("60 per minute")
+def performance_health_check():
+    """
+    Quick health check for performance monitoring.
+    
+    Returns:
+        JSON response with health status
+    """
+    try:
+        health_status = {
+            'timestamp': datetime.utcnow().isoformat(),
+            'status': 'healthy',
+            'checks': {}
+        }
+        
+        # Database health
+        try:
+            from sqlalchemy import text
+            from ..models.base import db
+            db.session.execute(text('SELECT 1'))
+            health_status['checks']['database'] = 'healthy'
+        except Exception as e:
+            health_status['checks']['database'] = f'unhealthy: {str(e)}'
+            health_status['status'] = 'degraded'
+        
+        # Redis health
+        connection_pool_manager = get_connection_pool_manager()
+        if connection_pool_manager:
+            redis_client = connection_pool_manager.get_redis_client()
+            if redis_client:
+                try:
+                    redis_client.ping()
+                    health_status['checks']['redis'] = 'healthy'
+                except Exception as e:
+                    health_status['checks']['redis'] = f'unhealthy: {str(e)}'
+                    health_status['status'] = 'degraded'
+            else:
+                health_status['checks']['redis'] = 'disabled'
+        else:
+            health_status['checks']['redis'] = 'no_pool_manager'
+        
+        # Cache service health
+        cache_service = get_cache_service()
+        if cache_service:
+            cache_stats = cache_service.get_cache_stats()
+            if cache_stats['cache_errors'] > 100:  # Arbitrary threshold
+                health_status['checks']['cache'] = 'degraded'
+                health_status['status'] = 'degraded'
+            else:
+                health_status['checks']['cache'] = 'healthy'
+        else:
+            health_status['checks']['cache'] = 'not_initialized'
+        
+        return jsonify(health_status)
+        
+    except Exception as e:
+        logger.error(f"Performance health check failed: {e}")
+        return jsonify({
+            'timestamp': datetime.utcnow().isoformat(),
+            'status': 'unhealthy',
+            'error': str(e)
+        }), 503
+
+
+# Error handlers
+@performance_bp.errorhandler(429)
+def handle_rate_limit_exceeded(error):
+    """Handle rate limit exceeded errors."""
+    return jsonify({
+        'error': 'Rate limit exceeded',
+        'message': 'Too many requests to performance endpoints. Please try again later.'
+    }), 429
+
+
+@performance_bp.errorhandler(500)
+def handle_internal_error(error):
+    """Handle internal server errors."""
+    logger.error(f"Performance endpoint internal error: {error}")
+    return jsonify({
+        'error': 'Internal server error',
+        'timestamp': datetime.utcnow().isoformat()
+    }), 500

chat_agent/models/__init__.py

@@ -0,0 +1,15 @@
+"""Models package for the chat agent application."""
+
+from .base import db, BaseModel
+from .message import Message
+from .chat_session import ChatSession
+from .language_context import LanguageContext
+
+# Export all models and database instance
+__all__ = [
+    'db',
+    'BaseModel',
+    'Message',
+    'ChatSession',
+    'LanguageContext'
+]

chat_agent/models/base.py

@@ -0,0 +1,61 @@
+"""Base model classes and database setup for the chat agent."""
+
+from datetime import datetime
+from uuid import uuid4
+from sqlalchemy import Column, DateTime, String, TypeDecorator
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from flask_sqlalchemy import SQLAlchemy
+
+# Create SQLAlchemy instance
+db = SQLAlchemy()
+
+# Custom UUID type that works with both PostgreSQL and SQLite
+class GUID(TypeDecorator):
+    """Platform-independent GUID type.
+    Uses PostgreSQL's UUID type, otherwise uses String(36).
+    """
+    impl = String
+    cache_ok = True
+
+    def load_dialect_impl(self, dialect):
+        if dialect.name == 'postgresql':
+            return dialect.type_descriptor(UUID(as_uuid=True))
+        else:
+            return dialect.type_descriptor(String(36))
+
+    def process_bind_param(self, value, dialect):
+        if value is None:
+            return value
+        elif dialect.name == 'postgresql':
+            return value
+        else:
+            return str(value)
+
+    def process_result_value(self, value, dialect):
+        if value is None:
+            return value
+        else:
+            return value
+
+# Base model class with common fields
+class BaseModel(db.Model):
+    """Base model class with common fields and methods."""
+    
+    __abstract__ = True
+    
+    id = Column(GUID(), primary_key=True, default=lambda: str(uuid4()))
+    created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)
+    
+    def to_dict(self):
+        """Convert model instance to dictionary."""
+        return {
+            column.name: getattr(self, column.name)
+            for column in self.__table__.columns
+        }
+    
+    def __repr__(self):
+        """String representation of the model."""
+        return f"<{self.__class__.__name__}(id={self.id})>"

chat_agent/models/chat_session.py

@@ -0,0 +1,118 @@
+"""ChatSession model for managing user chat sessions."""
+
+from datetime import datetime, timedelta
+from sqlalchemy import Column, String, DateTime, Integer, Boolean, JSON
+from sqlalchemy.orm import relationship
+from .base import BaseModel, db, GUID
+
+
+class ChatSession(BaseModel):
+    """Model for managing user chat sessions."""
+    
+    __tablename__ = 'chat_sessions'
+    
+    # Core session fields
+    user_id = Column(GUID(), nullable=False, index=True)
+    language = Column(String(50), nullable=False, default='python')
+    
+    # Activity tracking
+    last_active = Column(DateTime, default=datetime.utcnow, nullable=False, index=True)
+    message_count = Column(Integer, default=0, nullable=False)
+    is_active = Column(Boolean, default=True, nullable=False, index=True)
+    
+    # Session metadata
+    session_metadata = Column(JSON, default=dict)  # Additional session context, preferences, etc.
+    
+    # Relationships
+    messages = relationship("Message", back_populates="session", cascade="all, delete-orphan")
+    language_context = relationship("LanguageContext", back_populates="session", uselist=False, cascade="all, delete-orphan")
+    
+    def __init__(self, user_id, language='python', session_metadata=None):
+        """Initialize a new chat session."""
+        super().__init__()
+        self.user_id = user_id
+        self.language = language
+        self.last_active = datetime.utcnow()
+        self.message_count = 0
+        self.is_active = True
+        self.session_metadata = session_metadata or {}
+    
+    def update_activity(self):
+        """Update the last active timestamp."""
+        self.last_active = datetime.utcnow()
+        db.session.commit()
+    
+    def increment_message_count(self):
+        """Increment the message count for this session."""
+        self.message_count += 1
+        self.update_activity()
+    
+    def set_language(self, language):
+        """Set the programming language for this session."""
+        self.language = language
+        self.update_activity()
+    
+    def deactivate(self):
+        """Mark the session as inactive."""
+        self.is_active = False
+        db.session.commit()
+    
+    def is_expired(self, timeout_seconds=3600):
+        """Check if the session has expired based on last activity."""
+        if not self.last_active:
+            return True
+        
+        expiry_time = self.last_active + timedelta(seconds=timeout_seconds)
+        return datetime.utcnow() > expiry_time
+    
+    def get_recent_messages(self, limit=10):
+        """Get recent messages for this session."""
+        # Import here to avoid circular imports
+        from .message import Message
+        return (db.session.query(Message)
+                .filter(Message.session_id == self.id)
+                .order_by(Message.timestamp.desc())
+                .limit(limit)
+                .all())
+    
+    def to_dict(self):
+        """Convert session to dictionary with formatted timestamps."""
+        data = super().to_dict()
+        # Format timestamps as ISO strings for JSON serialization
+        if self.last_active:
+            data['last_active'] = self.last_active.isoformat()
+        return data
+    
+    @classmethod
+    def create_session(cls, user_id, language='python', session_metadata=None):
+        """Create a new chat session."""
+        session = cls(user_id=user_id, language=language, session_metadata=session_metadata)
+        db.session.add(session)
+        db.session.commit()
+        return session
+    
+    @classmethod
+    def get_active_sessions(cls, user_id=None):
+        """Get all active sessions, optionally filtered by user."""
+        query = db.session.query(cls).filter(cls.is_active == True)
+        if user_id:
+            query = query.filter(cls.user_id == user_id)
+        return query.all()
+    
+    @classmethod
+    def cleanup_expired_sessions(cls, timeout_seconds=3600):
+        """Clean up expired sessions."""
+        cutoff_time = datetime.utcnow() - timedelta(seconds=timeout_seconds)
+        expired_sessions = (db.session.query(cls)
+                          .filter(cls.last_active < cutoff_time)
+                          .filter(cls.is_active == True)
+                          .all())
+        
+        for session in expired_sessions:
+            session.deactivate()
+        
+        return len(expired_sessions)
+    
+    def __repr__(self):
+        """String representation of the session."""
+        return f"<ChatSession(id={self.id}, user_id={self.user_id}, language={self.language}, active={self.is_active})>"

chat_agent/models/language_context.py

@@ -0,0 +1,304 @@
+"""LanguageContext model for session-specific language settings."""
+
+from datetime import datetime
+from sqlalchemy import Column, String, Text, DateTime
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import relationship
+from .base import BaseModel, db, GUID
+
+
+class LanguageContext(BaseModel):
+    """Model for storing session-specific language settings and context."""
+    
+    __tablename__ = 'language_contexts'
+    
+    # Core context fields
+    session_id = Column(GUID(), ForeignKey('chat_sessions.id'), nullable=False, unique=True, index=True)
+    language = Column(String(50), nullable=False, default='python')
+    
+    # Language-specific settings
+    prompt_template = Column(Text, nullable=True)  # Custom prompt template for this language
+    syntax_highlighting = Column(String(50), nullable=True)  # Syntax highlighting scheme
+    
+    # Context metadata
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)
+    
+    # Relationships
+    session = relationship("ChatSession", back_populates="language_context")
+    
+    # Supported programming languages with enhanced prompt templates
+    SUPPORTED_LANGUAGES = {
+        'python': {
+            'name': 'Python',
+            'syntax_highlighting': 'python',
+            'file_extensions': ['.py', '.pyw'],
+            'prompt_template': '''You are an expert Python programming tutor and assistant. Your role is to help students learn Python by providing clear, accurate, and educational responses. Always:
+
+1. Use simple, beginner-friendly language
+2. Provide practical examples with detailed explanations
+3. Explain the 'why' behind concepts, not just the 'how'
+4. Encourage Python best practices and PEP 8 style guidelines
+5. Be patient and supportive, especially with beginners
+6. When explaining errors, provide step-by-step debugging guidance
+7. Use code comments to explain complex parts
+8. Suggest improvements and alternative approaches when appropriate
+
+Focus on helping students understand Python concepts deeply rather than just providing quick fixes.''',
+            'assistance_features': {
+                'code_explanation': True,
+                'debugging': True,
+                'error_analysis': True,
+                'code_review': True,
+                'concept_clarification': True,
+                'beginner_help': True
+            }
+        },
+        'javascript': {
+            'name': 'JavaScript',
+            'syntax_highlighting': 'javascript',
+            'file_extensions': ['.js', '.mjs'],
+            'prompt_template': '''You are an expert JavaScript programming tutor and assistant. Your role is to help students learn JavaScript by providing clear, accurate, and educational responses. Always:
+
+1. Use simple, beginner-friendly language
+2. Provide practical examples with detailed explanations
+3. Explain modern JavaScript (ES6+) features and best practices
+4. Help with both frontend and backend JavaScript concepts
+5. Be patient and supportive, especially with beginners
+6. When explaining errors, provide step-by-step debugging guidance
+7. Use code comments to explain complex parts
+8. Suggest improvements and modern JavaScript patterns
+
+Focus on helping students understand JavaScript concepts deeply, including asynchronous programming, DOM manipulation, and modern frameworks.''',
+            'assistance_features': {
+                'code_explanation': True,
+                'debugging': True,
+                'error_analysis': True,
+                'code_review': True,
+                'concept_clarification': True,
+                'beginner_help': True
+            }
+        },
+        'typescript': {
+            'name': 'TypeScript',
+            'syntax_highlighting': 'typescript',
+            'file_extensions': ['.ts', '.tsx'],
+            'prompt_template': '''You are an expert TypeScript programming tutor and assistant. Your role is to help students learn TypeScript by providing clear, accurate, and educational responses. Always:
+
+1. Use simple, beginner-friendly language
+2. Provide practical examples with detailed type annotations
+3. Explain TypeScript's type system and its benefits over JavaScript
+4. Help with both basic and advanced TypeScript features
+5. Be patient and supportive, especially with beginners
+6. When explaining errors, focus on type-related issues and solutions
+7. Use code comments to explain complex type definitions
+8. Suggest improvements using TypeScript's powerful type features
+
+Focus on helping students understand TypeScript's type system and how it enhances JavaScript development.''',
+            'assistance_features': {
+                'code_explanation': True,
+                'debugging': True,
+                'error_analysis': True,
+                'code_review': True,
+                'concept_clarification': True,
+                'beginner_help': True
+            }
+        },
+        'java': {
+            'name': 'Java',
+            'syntax_highlighting': 'java',
+            'file_extensions': ['.java'],
+            'prompt_template': '''You are an expert Java programming tutor and assistant. Your role is to help students learn Java by providing clear, accurate, and educational responses. Always:
+
+1. Use simple, beginner-friendly language
+2. Provide practical examples with detailed explanations
+3. Explain object-oriented programming concepts clearly
+4. Help with Java syntax, conventions, and best practices
+5. Be patient and supportive, especially with beginners
+6. When explaining errors, provide step-by-step debugging guidance
+7. Use code comments to explain complex parts
+8. Suggest improvements following Java conventions
+
+Focus on helping students understand Java's object-oriented nature, strong typing, and enterprise development patterns.''',
+            'assistance_features': {
+                'code_explanation': True,
+                'debugging': True,
+                'error_analysis': True,
+                'code_review': True,
+                'concept_clarification': True,
+                'beginner_help': True
+            }
+        },
+        'cpp': {
+            'name': 'C++',
+            'syntax_highlighting': 'cpp',
+            'file_extensions': ['.cpp', '.cc', '.cxx', '.h', '.hpp'],
+            'prompt_template': '''You are an expert C++ programming tutor and assistant. Your role is to help students learn C++ by providing clear, accurate, and educational responses. Always:
+
+1. Use simple, beginner-friendly language
+2. Provide practical examples with detailed explanations
+3. Explain memory management and pointer concepts clearly
+4. Help with both C++11/14/17/20 features and classic C++
+5. Be patient and supportive, especially with beginners
+6. When explaining errors, focus on compilation and runtime issues
+7. Use code comments to explain complex parts
+8. Suggest improvements following modern C++ best practices
+
+Focus on helping students understand C++'s power and complexity, including memory management, templates, and modern C++ features.''',
+            'assistance_features': {
+                'code_explanation': True,
+                'debugging': True,
+                'error_analysis': True,
+                'code_review': True,
+                'concept_clarification': True,
+                'beginner_help': True
+            }
+        },
+        'csharp': {
+            'name': 'C#',
+            'syntax_highlighting': 'csharp',
+            'file_extensions': ['.cs'],
+            'prompt_template': '''You are an expert C# programming tutor and assistant. Your role is to help students learn C# by providing clear, accurate, and educational responses. Always:
+
+1. Use simple, beginner-friendly language
+2. Provide practical examples with detailed explanations
+3. Explain .NET framework and C# language features
+4. Help with object-oriented programming in C#
+5. Be patient and supportive, especially with beginners
+6. When explaining errors, provide step-by-step debugging guidance
+7. Use code comments to explain complex parts
+8. Suggest improvements following C# conventions and best practices
+
+Focus on helping students understand C#'s integration with .NET, strong typing, and enterprise development patterns.''',
+            'assistance_features': {
+                'code_explanation': True,
+                'debugging': True,
+                'error_analysis': True,
+                'code_review': True,
+                'concept_clarification': True,
+                'beginner_help': True
+            }
+        },
+        'go': {
+            'name': 'Go',
+            'syntax_highlighting': 'go',
+            'file_extensions': ['.go'],
+            'prompt_template': '''You are an expert Go programming tutor and assistant. Your role is to help students learn Go by providing clear, accurate, and educational responses. Always:
+
+1. Use simple, beginner-friendly language
+2. Provide practical examples with detailed explanations
+3. Explain Go's simplicity and concurrency features
+4. Help with Go idioms and best practices
+5. Be patient and supportive, especially with beginners
+6. When explaining errors, provide step-by-step debugging guidance
+7. Use code comments to explain complex parts
+8. Suggest improvements following Go conventions
+
+Focus on helping students understand Go's philosophy of simplicity, its powerful concurrency model, and systems programming concepts.''',
+            'assistance_features': {
+                'code_explanation': True,
+                'debugging': True,
+                'error_analysis': True,
+                'code_review': True,
+                'concept_clarification': True,
+                'beginner_help': True
+            }
+        },
+        'rust': {
+            'name': 'Rust',
+            'syntax_highlighting': 'rust',
+            'file_extensions': ['.rs'],
+            'prompt_template': '''You are an expert Rust programming tutor and assistant. Your role is to help students learn Rust by providing clear, accurate, and educational responses. Always:
+
+1. Use simple, beginner-friendly language
+2. Provide practical examples with detailed explanations
+3. Explain Rust's ownership system and memory safety features
+4. Help with Rust's unique concepts like borrowing and lifetimes
+5. Be patient and supportive, especially with beginners
+6. When explaining errors, focus on the borrow checker and compiler messages
+7. Use code comments to explain complex parts
+8. Suggest improvements following Rust idioms and best practices
+
+Focus on helping students understand Rust's ownership model, memory safety guarantees, and systems programming concepts.''',
+            'assistance_features': {
+                'code_explanation': True,
+                'debugging': True,
+                'error_analysis': True,
+                'code_review': True,
+                'concept_clarification': True,
+                'beginner_help': True
+            }
+        }
+    }
+    
+    def __init__(self, session_id, language='python'):
+        """Initialize a new language context."""
+        super().__init__()
+        self.session_id = session_id
+        self.set_language(language)
+    
+    def set_language(self, language):
+        """Set the programming language and update related settings."""
+        if not self.is_supported_language(language):
+            raise ValueError(f"Unsupported language: {language}")
+        
+        self.language = language
+        language_config = self.SUPPORTED_LANGUAGES[language]
+        self.syntax_highlighting = language_config['syntax_highlighting']
+        self.prompt_template = language_config['prompt_template']
+        self.updated_at = datetime.utcnow()
+    
+    def get_prompt_template(self):
+        """Get the prompt template for the current language."""
+        return self.prompt_template or self.SUPPORTED_LANGUAGES.get(self.language, {}).get('prompt_template', '')
+    
+    def get_syntax_highlighting(self):
+        """Get the syntax highlighting scheme for the current language."""
+        return self.syntax_highlighting or self.SUPPORTED_LANGUAGES.get(self.language, {}).get('syntax_highlighting', 'text')
+    
+    def get_language_info(self):
+        """Get complete language information."""
+        return self.SUPPORTED_LANGUAGES.get(self.language, {})
+    
+    @classmethod
+    def is_supported_language(cls, language):
+        """Check if a programming language is supported."""
+        return language.lower() in cls.SUPPORTED_LANGUAGES
+    
+    @classmethod
+    def get_supported_languages(cls):
+        """Get list of all supported programming languages."""
+        return list(cls.SUPPORTED_LANGUAGES.keys())
+    
+    @classmethod
+    def get_language_display_names(cls):
+        """Get mapping of language codes to display names."""
+        return {
+            code: config['name'] 
+            for code, config in cls.SUPPORTED_LANGUAGES.items()
+        }
+    
+    @classmethod
+    def create_context(cls, session_id, language='python'):
+        """Create a new language context for a session."""
+        context = cls(session_id=session_id, language=language)
+        db.session.add(context)
+        db.session.commit()
+        return context
+    
+    @classmethod
+    def get_or_create_context(cls, session_id, language='python'):
+        """Get existing context or create a new one."""
+        context = db.session.query(cls).filter(cls.session_id == session_id).first()
+        if not context:
+            context = cls.create_context(session_id, language)
+        return context
+    
+    def to_dict(self):
+        """Convert context to dictionary."""
+        data = super().to_dict()
+        data['language_info'] = self.get_language_info()
+        return data
+    
+    def __repr__(self):
+        """String representation of the language context."""
+        return f"<LanguageContext(session_id={self.session_id}, language={self.language})>"