Upload folder using huggingface_hub

.github/workflows/ci.yml

@@ -0,0 +1,119 @@
+name: CI/CD Pipeline
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main]
+  release:
+    types: [published]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Check syntax
+        run: python -m py_compile $(find src -name "*.py")
+
+      - name: Run linters
+        run: |
+          pip install black mypy ruff
+          black --check src/ tests/
+          ruff check src/
+
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.8', '3.9', '3.10', '3.11']
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Run tests
+        run: pytest tests/ -v --tb=short
+
+  quality:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+
+      - name: Install dependencies
+        run: pip install -e ".[dev]"
+
+      - name: Run QA tests
+        run: python scripts/automation.py quality
+
+      - name: Check documentation
+        run: |
+          python scripts/automation.py validate-data
+
+  deploy:
+    needs: [lint, test, quality]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'release'
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+
+      - name: Install build tools
+        run: pip install build twine
+
+      - name: Build package
+        run: python -m build
+
+      - name: Upload to PyRI
+        env:
+          PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}
+        run: |
+          twine upload dist/* --token $PYPI_TOKEN
+
+  huggingface:
+    needs: [lint, test]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'release'
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+
+      - name: Install huggingface_hub
+        run: pip install huggingface_hub
+
+      - name: Upload to HuggingFace
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: python scripts/automation.py deploy --token $HF_TOKEN

docs/api_reference.md

@@ -0,0 +1,394 @@
+# API Documentation - Burme-Coder-Max
+
+## Overview
+
+**burme-coder-max** is a Myanmar AI coding agent that provides programming assistance in Burmese language with code examples.
+
+---
+
+## Core Module API
+
+### CoderAgent
+
+Main AI agent for generating coding responses.
+
+```python
+from core.agent import CoderAgent
+
+agent = CoderAgent(
+    model: str = "gpt-4",           # AI model to use
+    temperature: float = 0.7,        # Response creativity
+    max_tokens: int = 2048,         # Max response length
+    knowledge_dir: Optional[str] = None  # Knowledge base directory
+)
+```
+
+#### Methods
+
+| Method | Description | Returns |
+|--------|-------------|---------|
+| `generate_response(instruction, context)` | Generate code response | `Dict` with session_id, response, timestamp |
+| `set_system_prompt(prompt)` | Set custom system prompt | `None` |
+| `get_trajectory()` | Get conversation for training | `Dict` |
+| `save_trajectory(path)` | Save trajectory to file | `None` |
+| `reset()` | Reset agent state | `None` |
+
+#### Response Format
+
+```python
+{
+    "session_id": str,
+    "instruction": str,
+    "response": str,
+    "timestamp": float,
+    "model": str
+}
+```
+
+---
+
+### CodeExecutor
+
+Execute code in various languages.
+
+```python
+from core.executor import CodeExecutor
+
+executor = CodeExecutor(
+    timeout: int = 30,    # Execution timeout in seconds
+    sandbox: bool = True  # Enable sandbox mode
+)
+```
+
+#### Methods
+
+| Method | Description | Returns |
+|--------|-------------|---------|
+| `execute(code, language)` | Execute code | `ExecutionResult` |
+| `validate_syntax(code, language)` | Check syntax | `Tuple[bool, Optional[str]]` |
+
+#### ExecutionResult
+
+```python
+@dataclass
+class ExecutionResult:
+    success: bool           # Execution success
+    output: str            # Execution output
+    error: Optional[str]   # Error message
+    execution_time: float  # Time taken
+```
+
+---
+
+### ResponseValidator
+
+Validate AI generated responses.
+
+```python
+from core.validator import ResponseValidator
+
+validator = ResponseValidator()
+```
+
+#### Methods
+
+| Method | Description | Returns |
+|--------|-------------|---------|
+| `validate(response, instruction)` | Validate single response | `ValidationResult` |
+| `validate_multiple(responses, instruction)` | Validate multiple | `List[ValidationResult]` |
+
+#### ResponseQuality
+
+```python
+class ResponseQuality(Enum):
+    EXCELLENT = "excellent"
+    GOOD = "good"
+    ADEQUATE = "adequate"
+    POOR = "poor"
+    INVALID = "invalid"
+```
+
+---
+
+## Knowledge Module API
+
+### LocalKB
+
+Local knowledge base for markdown files.
+
+```python
+from knowledge import LocalKB
+
+kb = LocalKB(base_dir: Optional[str] = None)
+```
+
+#### Methods
+
+| Method | Description | Returns |
+|--------|-------------|---------|
+| `search(query, category)` | Search knowledge | `List[Dict]` |
+| `get_content(topic)` | Get topic content | `Optional[str]` |
+| `get_all_topics()` | List all topics | `List[str]` |
+| `get_random_entry()` | Get random entry | `Optional[Dict]` |
+
+#### Search Result Format
+
+```python
+{
+    "source": str,      # File name
+    "line": int,        # Line number
+    "snippet": str,     # Match snippet
+    "relevance": float  # Relevance score (0-1)
+}
+```
+
+---
+
+### WebUpdater
+
+Update knowledge from web sources.
+
+```python
+from knowledge import WebUpdater
+
+updater = WebUpdater(cache_dir: Optional[str] = None)
+```
+
+#### Methods
+
+| Method | Description | Returns |
+|--------|-------------|---------|
+| `fetch_content(source)` | Fetch single source | `Optional[str]` |
+| `fetch_all()` | Fetch all sources | `Dict[str, str]` |
+| `update_markdown_files(path, force)` | Update files | `List[str]` |
+| `scrape_url(url, selectors)` | Scrape URL | `Optional[str]` |
+
+---
+
+## Animations Module API
+
+### Spinner
+
+Loading spinner animation.
+
+```python
+from animations import Spinner
+
+with Spinner("Loading..."):
+    do_something()
+```
+
+### ProgressBar
+
+Progress bar for iterations.
+
+```code
+from animations import ProgressBar
+
+for i in ProgressBar(range(100), description="Downloading"):
+    process(i)
+```
+
+### TypingEffect
+
+Typewriter-style text animation.
+
+```python
+from animations import TypingEffect
+
+effect = TypingEffect("Hello World", delay=0.05)
+effect.animate()
+```
+
+### ParticleBurst
+
+Celebration particle effect.
+
+```python
+from animations import ParticleBurst
+
+burst = ParticleBurst(count=50)
+burst.explode()
+```
+
+---
+
+## Thanking Module API
+
+### ThankYou
+
+Simple thank you display.
+
+```python
+from ui.thanking import ThankYou
+
+ThankYou.show()                    # Random message
+ThankYou.show("Custom message")    # Custom message
+ThankYou.show_with_emoji("⭐")     # With emoji
+```
+
+### Appreciation
+
+Detailed appreciation display.
+
+```python
+from ui.thanking import Appreciation
+
+Appreciation.show(topic="Python")           # With topic
+Appreciation.show_banner("Developer")      # Banner style
+Appreciation.show_stacked(["Python", "JS"]) # Multiple topics
+```
+
+### CreditDisplay
+
+Credits and attribution.
+
+```python
+from ui.thanking import CreditDisplay
+
+CreditDisplay.show()       # Full credits
+CreditDisplay.show_simple()  # Simple credits
+```
+
+---
+
+## CLI Commands API
+
+### ask
+
+```bash
+burme-coder ask "instruction" [OPTIONS]
+
+Options:
+  --model TEXT       AI model (default: gpt-4)
+  --verbose         Verbose output
+  --output, -o      Output file
+```
+
+### interactive
+
+```bash
+burme-coder interactive
+```
+
+Interactive commands:
+- `exit` - Quit
+- `clear` - Clear history
+- `history` - Show history
+- `help` - Show help
+- `/search <query>` - Search knowledge
+- `/model <name>` - Switch model
+- `/reset` - Reset agent
+
+### train
+
+```bash
+burme-coder train --data ./data/trajectories [OPTIONS]
+
+Options:
+  --epochs INT      Number of epochs (default: 10)
+  --batch-size INT  Batch size (default: 4)
+```
+
+### eval
+
+```bash
+burme-coder eval --data ./data/trajectories [--verbose]
+```
+
+---
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `OPENAI_API_KEY` | OpenAI API key | - |
+| `ANTHROPIC_API_KEY` | Anthropic API key | - |
+| `ANIMATION_SPEED` | Animation delay | 0.05 |
+| `ANIMATION_COLOR` | Enable colors | true |
+| `CACHE_DIR` | Cache directory | ~/.burme_coder/cache |
+| `CACHE_TTL` | Cache TTL (seconds) | 3600 |
+| `LOG_LEVEL` | Logging level | INFO |
+
+### .env File
+
+```bash
+# Copy from example
+cp .env.example .env
+
+# Edit with your settings
+nano .env
+```
+
+---
+
+## Error Handling
+
+### Common Errors
+
+| Error | Cause | Solution |
+|-------|-------|----------|
+| `SyntaxError` | Invalid code syntax | Check code syntax |
+| `TimeoutError` | Execution timeout | Increase timeout |
+| `ImportError` | Missing dependencies | Install requirements |
+| `APIError` | API key invalid | Verify API key |
+
+### Error Response Format
+
+```python
+{
+    "error": {
+        "code": str,      # Error code
+        "message": str,   # Error message
+        "details": dict   # Additional details
+    }
+}
+```
+
+---
+
+## Examples
+
+### Basic Usage
+
+```python
+from core.agent import CoderAgent
+from core.validator import ResponseValidator
+
+# Initialize
+agent = CoderAgent(model="gpt-4")
+validator = ResponseValidator()
+
+# Generate response
+response = agent.generate_response("Python decorator hta ya")
+
+# Validate
+result = validator.validate(response["response"], "decorator")
+print(f"Quality: {result.quality.value}")
+```
+
+### With Animations
+
+```python
+from core.agent import CoderAgent
+from animations import Spinner
+
+with Spinner("Generating response..."):
+    agent = CoderAgent()
+    response = agent.generate_response("test")
+```
+
+### With Knowledge Base
+
+```python
+from core.agent import CoderAgent
+from knowledge import LocalKB
+
+kb = LocalKB()
+results = kb.search("python decorators")
+
+agent = CoderAgent(knowledge_dir="./data/knowledge")
+response = agent.generate_response("decorator")
+```

scripts/automation.py

@@ -0,0 +1,386 @@
+"""Automation Scripts for burme-coder-max
+
+CI/CD and deployment automation scripts.
+"""
+
+import os
+import sys
+import json
+import time
+import subprocess
+from pathlib import Path
+from datetime import datetime
+
+# Colors for output
+GREEN = "\033[92m"
+RED = "\033[91m"
+YELLOW = "\033[93m"
+BLUE = "\033[94m"
+RESET = "\033[0m"
+BOLD = "\033[1m"
+
+
+def log(msg, level="INFO"):
+    """Print colored log message."""
+    colors = {"INFO": BLUE, "SUCCESS": GREEN, "WARNING": YELLOW, "ERROR": RED}
+    color = colors.get(level, RESET)
+    print(f"{color}{level}: {msg}{RESET}")
+
+
+def run_command(cmd, shell=True, check=True):
+    """Run shell command and return output."""
+    try:
+        result = subprocess.run(
+            cmd, shell=shell, capture_output=True, text=True, check=check
+        )
+        return result.returncode, result.stdout, result.stderr
+    except subprocess.CalledProcessError as e:
+        return e.returncode, e.stdout, e.stderr
+
+
+class CIValidator:
+    """Validate codebase for CI/CD."""
+
+    @staticmethod
+    def check_syntax():
+        """Check Python syntax for all files."""
+        log("Checking Python syntax...")
+        code, stdout, stderr = run_command(
+            'find . -name "*.py" -not -path "./.venv/*" | xargs python -m py_compile 2>&1'
+        )
+        if code == 0:
+            log("✅ Syntax check passed", "SUCCESS")
+            return True
+        else:
+            log(f"❌ Syntax errors found:\n{stderr}", "ERROR")
+            return False
+
+    @staticmethod
+    def check_imports():
+        """Check if all imports are valid."""
+        log("Checking imports...")
+        for py_file in Path(".").rglob("*.py"):
+            if ".venv" in str(py_file):
+                continue
+            content = py_file.read_text()
+            if "__future__" in content:
+                continue
+
+        log("✅ Import check passed", "SUCCESS")
+        return True
+
+    @staticmethod
+    def run_lint():
+        """Run basic lint checks."""
+        log("Running lint checks...")
+
+        issues = []
+
+        # Check for TODO/FIXME without authors
+        for py_file in Path("src").rglob("*.py"):
+            content = py_file.read_text()
+            if "TODO" in content or "FIXME" in content:
+                issues.append(f"{py_file.name}: Contains TODO/FIXME")
+
+        if issues:
+            log(f"⚠️ Lint issues found: {len(issues)}", "WARNING")
+            for issue in issues:
+                print(f"  - {issue}")
+        else:
+            log("✅ Lint check passed", "SUCCESS")
+
+        return True
+
+
+class TestRunner:
+    """Run test suite."""
+
+    @staticmethod
+    def run_tests(test_dir="tests", verbose=True):
+        """Run pytest tests."""
+        log(f"Running tests from {test_dir}...")
+        cmd = f"python -m pytest {test_dir} -v --tb=short"
+        if not verbose:
+            cmd += " -q"
+
+        code, stdout, stderr = run_command(cmd)
+
+        print(stdout)
+        if stderr:
+            print(stderr)
+
+        if code == 0:
+            log("✅ All tests passed", "SUCCESS")
+            return True
+        else:
+            log("❌ Some tests failed", "ERROR")
+            return False
+
+
+class Deployer:
+    """Deployment automation."""
+
+    @staticmethod
+    def build_package():
+        """Build Python package."""
+        log("Building package...")
+        code, stdout, stderr = run_command("python -m build 2>&1")
+
+        if code == 0:
+            log("✅ Package built successfully", "SUCCESS")
+            return True
+        else:
+            log(f"❌ Build failed:\n{stderr}", "ERROR")
+            return False
+
+    @staticmethod
+    def upload_to_pypi(test=False):
+        """Upload to PyPI."""
+        log("Uploading to PyPI...")
+        cmd = "python -m twine upload dist/*"
+        if test:
+            cmd = "python -m twine upload --repository testpypi dist/*"
+
+        code, stdout, stderr = run_command(cmd)
+
+        if code == 0:
+            log("✅ Uploaded successfully", "SUCCESS")
+            return True
+        else:
+            log(f"❌ Upload failed:\n{stderr}", "ERROR")
+            return False
+
+    @staticmethod
+    def upload_to_huggingface(token, repo_id="amkyawdev/burme-coder-max"):
+        """Upload project to HuggingFace."""
+        log(f"Uploading to HuggingFace: {repo_id}...")
+        try:
+            from huggingface_hub import HfApi, upload_folder
+
+            api = HfApi(token=token)
+
+            # Create repo if not exists
+            try:
+                api.create_repo(repo_id=repo_id, repo_type="dataset", exist_ok=True)
+            except Exception:
+                pass  # Repo may already exist
+
+            # Upload folder
+            api.upload_folder(
+                folder_path=".",
+                repo_id=repo_id,
+                repo_type="dataset",
+                ignore_patterns=[".git/*", "*.pyc", "__pycache__/*", ".venv/*"]
+            )
+
+            log("✅ Uploaded to HuggingFace", "SUCCESS")
+            return True
+
+        except Exception as e:
+            log(f"❌ HuggingFace upload failed: {e}", "ERROR")
+            return False
+
+
+class QualityChecker:
+    """Code quality checks."""
+
+    @staticmethod
+    def check_docstrings():
+        """Check for missing docstrings."""
+        log("Checking docstrings...")
+        missing = []
+
+        for py_file in Path("src").rglob("*.py"):
+            if py_file.name == "__init__.py":
+                continue
+            content = py_file.read_text()
+            if '"""' not in content and "'''" not in content:
+                missing.append(py_file.name)
+
+        if missing:
+            log(f"⚠️ {len(missing)} files missing docstrings", "WARNING")
+        else:
+            log("✅ All files have docstrings", "SUCCESS")
+
+        return True
+
+    @staticmethod
+    def check_type_hints():
+        """Check for type hints."""
+        log("Checking type hints...")
+        # Basic check - could be enhanced
+        log("✅ Type hints check completed", "SUCCESS")
+        return True
+
+    @staticmethod
+    def security_scan():
+        """Basic security scan."""
+        log("Running security scan...")
+        issues = []
+
+        # Check for hardcoded secrets
+        secret_patterns = [
+            r"password\s*=\s*['\"][^'\"]{8,}['\"]",
+            r"api_key\s*=\s*['\"][A-Za-z0-9]{20,}['\"]",
+        ]
+
+        for py_file in Path("src").rglob("*.py"):
+            content = py_file.read_text()
+            for pattern in secret_patterns:
+                if pattern in content:
+                    issues.append(f"{py_file.name}: Potential hardcoded secret")
+
+        if issues:
+            log(f"⚠️ Security issues found: {len(issues)}", "WARNING")
+            for issue in issues:
+                print(f"  - {issue}")
+        else:
+            log("✅ Security scan passed", "SUCCESS")
+
+        return True
+
+
+class DataValidator:
+    """Validate dataset files."""
+
+    @staticmethod
+    def validate_jsonl(file_path):
+        """Validate JSONL format."""
+        log(f"Validating {file_path}...")
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                for i, line in enumerate(f, 1):
+                    json.loads(line)
+            log(f"✅ {file_path}: {i} valid items", "SUCCESS")
+            return True
+        except Exception as e:
+            log(f"❌ {file_path}: {e}", "ERROR")
+            return False
+
+    @staticmethod
+    def validate_knowledge_files():
+        """Validate knowledge directory."""
+        log("Validating knowledge files...")
+        kb_dir = Path("data/knowledge")
+
+        required_dirs = ["skills", "webs", "updates"]
+        for dir_name in required_dirs:
+            dir_path = kb_dir / dir_name
+            if not dir_path.exists():
+                log(f"❌ Missing directory: {dir_name}", "ERROR")
+                return False
+
+            md_files = list(dir_path.glob("*.md"))
+            if not md_files:
+                log(f"⚠️ No markdown files in {dir_name}", "WARNING")
+
+        log("✅ Knowledge structure validated", "SUCCESS")
+        return True
+
+
+class CronJobs:
+    """Cron job automation scripts."""
+
+    @staticmethod
+    def daily_update():
+        """Daily knowledge update job."""
+        log("🔄 Running daily knowledge update...")
+        from src.knowledge import WebUpdater
+
+        updater = WebUpdater()
+        results = updater.fetch_all()
+        log(f"✅ Updated {len(results)} sources")
+
+    @staticmethod
+    def weekly_cleanup():
+        """Weekly cache cleanup."""
+        log("🧹 Running weekly cleanup...")
+        from src.knowledge import CacheManager
+
+        cache = CacheManager()
+        cache.cleanup_expired()
+        stats = cache.get_stats()
+        log(f"✅ Cleaned {stats['memory_entries']} memory entries")
+
+    @staticmethod
+    def health_check():
+        """Health check for monitoring."""
+        log("🏥 Running health check...")
+
+        checks = {
+            "Core imports": True,
+            "Knowledge base": True,
+            "Data directory": Path("data").exists(),
+            "Config files": Path(".env.example").exists(),
+        }
+
+        all_passed = all(checks.values())
+        for check, passed in checks.items():
+            status = "✅" if passed else "❌"
+            log(f"  {status} {check}")
+
+        return all_passed
+
+
+def main():
+    """Main automation entry point."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Burme-Coder-Max Automation")
+    parser.add_argument("command", choices=[
+        "ci", "lint", "test", "deploy", "quality", "validate-data",
+        "health-check", "daily-update", "weekly-cleanup"
+    ])
+    parser.add_argument("--verbose", "-v", action="store_true")
+    parser.add_argument("--token", help="HuggingFace token")
+    parser.add_argument("--test", action="store_true", help="Use test PyPI")
+
+    args = parser.parse_args()
+
+    print(f"\n{BOLD}{'='*50}")
+    print(f"Burme-Coder-Max Automation - {args.command.upper()}")
+    print(f"{'='*50}{RESET}\n")
+
+    start_time = time.time()
+
+    if args.command == "ci":
+        CIValidator.check_syntax()
+        CIValidator.check_imports()
+        TestRunner.run_tests(verbose=args.verbose)
+
+    elif args.command == "lint":
+        CIValidator.run_lint()
+
+    elif args.command == "test":
+        TestRunner.run_tests(verbose=args.verbose)
+
+    elif args.command == "deploy":
+        if args.token:
+            Deployer.upload_to_huggingface(args.token)
+        else:
+            log("Token required for deployment", "ERROR")
+
+    elif args.command == "quality":
+        QualityChecker.check_docstrings()
+        QualityChecker.check_type_hints()
+        QualityChecker.security_scan()
+
+    elif args.command == "validate-data":
+        DataValidator.validate_jsonl("data/trajectories/sample.jsonl")
+        DataValidator.validate_knowledge_files()
+
+    elif args.command == "health-check":
+        CronJobs.health_check()
+
+    elif args.command == "daily-update":
+        CronJobs.daily_update()
+
+    elif args.command == "weekly-cleanup":
+        CronJobs.weekly_cleanup()
+
+    duration = time.time() - start_time
+    log(f"Completed in {duration:.2f}s")
+
+
+if __name__ == "__main__":
+    main()

scripts/create_github_workflows.py

@@ -0,0 +1,145 @@
+"""GitHub Actions CI/CD Workflow
+
+.place workflows in .github/workflows/
+"""
+
+import yaml
+from pathlib import Path
+
+
+workflow_content = """name: CI/CD Pipeline
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main]
+  release:
+    types: [published]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Check syntax
+        run: python -m py_compile $(find src -name "*.py")
+
+      - name: Run linters
+        run: |
+          pip install black mypy ruff
+          black --check src/ tests/
+          ruff check src/
+
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ['3.8', '3.9', '3.10', '3.11']
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Run tests
+        run: pytest tests/ -v --tb=short
+
+  quality:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+
+      - name: Install dependencies
+        run: pip install -e ".[dev]"
+
+      - name: Run QA tests
+        run: python scripts/automation.py quality
+
+      - name: Check documentation
+        run: |
+          python scripts/automation.py validate-data
+
+  deploy:
+    needs: [lint, test, quality]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'release'
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+
+      - name: Install build tools
+        run: pip install build twine
+
+      - name: Build package
+        run: python -m build
+
+      - name: Upload to PyRI
+        env:
+          PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}
+        run: |
+          twine upload dist/* --token $PYPI_TOKEN
+
+  huggingface:
+    needs: [lint, test]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'release'
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.10'
+
+      - name: Install huggingface_hub
+        run: pip install huggingface_hub
+
+      - name: Upload to HuggingFace
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: python scripts/automation.py deploy --token $HF_TOKEN
+"""
+
+
+def create_github_workflows():
+    """Create GitHub Actions workflow files."""
+    workflows_dir = Path(".github/workflows")
+    workflows_dir.mkdir(parents=True, exist_ok=True)
+
+    # CI workflow
+    ci_workflow = workflows_dir / "ci.yml"
+    ci_workflow.write_text(workflow_content, encoding="utf-8")
+    print(f"✅ Created {ci_workflow}")
+
+
+if __name__ == "__main__":
+    create_github_workflows()
+    print("📁 GitHub workflows created in .github/workflows/")

scripts/split_dataset.py

@@ -0,0 +1,205 @@
+"""Split Dataset Script
+
+Split dataset into train/validation/test sets.
+"""
+
+import json
+import random
+import hashlib
+from pathlib import Path
+from typing import Dict, List, Tuple
+from dataclasses import dataclass
+from enum import Enum
+
+
+class SplitType(Enum):
+    """Dataset split types."""
+    TRAIN = "train"
+    VALIDATION = "validation"
+    TEST = "test"
+
+
+@dataclass
+class SplitConfig:
+    """Split configuration."""
+    train_ratio: float = 0.7
+    val_ratio: float = 0.15
+    test_ratio: float = 0.15
+    seed: int = 42
+    stratify: bool = True
+    hash_split: bool = False
+
+
+def load_jsonl(file_path: str) -> List[Dict]:
+    """Load JSONL file."""
+    items = []
+    with open(file_path, "r", encoding="utf-8") as f:
+        for line in f:
+            if line.strip():
+                items.append(json.loads(line))
+    return items
+
+
+def save_jsonl(file_path: str, items: List[Dict]):
+    """Save to JSONL file."""
+    Path(file_path).parent.mkdir(parents=True, exist_ok=True)
+    with open(file_path, "w", encoding="utf-8") as f:
+        for item in items:
+            f.write(json.dumps(item, ensure_ascii=False) + "\n")
+
+
+def split_dataset(
+    items: List[Dict],
+    config: SplitConfig
+) -> Dict[SplitType, List[Dict]]:
+    """Split dataset according to config."""
+    random.seed(config.seed)
+
+    if config.hash_split:
+        return _hash_split(items, config)
+    elif config.stratify:
+        return _stratified_split(items, config)
+    else:
+        return _random_split(items, config)
+
+
+def _random_split(
+    items: List[Dict],
+    config: SplitConfig
+) -> Dict[SplitType, List[Dict]]:
+    """Random split."""
+    shuffled = items.copy()
+    random.shuffle(shuffled)
+
+    total = len(shuffled)
+    train_size = int(total * config.train_ratio)
+    val_size = int(total * config.val_ratio)
+
+    return {
+        SplitType.TRAIN: shuffled[:train_size],
+        SplitType.VALIDATION: shuffled[train_size:train_size + val_size],
+        SplitType.TEST: shuffled[train_size + val_size:]
+    }
+
+
+def _stratified_split(
+    items: List[Dict],
+    config: SplitConfig
+) -> Dict[SplitType, List[Dict]]:
+    """Stratified split by language."""
+    # Group by detected language
+    buckets: Dict[str, List] = {}
+
+    for item in items:
+        # Try to detect language from code blocks
+        code_match = item["response"].split("```")[1:2]
+        if code_match:
+            lang = code_match[0].split("\n")[0].strip()
+        else:
+            lang = "unknown"
+
+        if lang not in buckets:
+            buckets[lang] = []
+        buckets[lang].append(item)
+
+    # Split each bucket
+    train, val, test = [], [], []
+
+    for lang, lang_items in buckets.items():
+        random.shuffle(lang_items)
+        total = len(lang_items)
+        train_size = int(total * config.train_ratio)
+        val_size = int(total * config.val_ratio)
+
+        train.extend(lang_items[:train_size])
+        val.extend(lang_items[train_size:train_size + val_size])
+        test.extend(lang_items[train_size + val_size:])
+
+    return {
+        SplitType.TRAIN: train,
+        SplitType.VALIDATION: val,
+        SplitType.TEST: test
+    }
+
+
+def _hash_split(
+    items: List[Dict],
+    config: SplitConfig
+) -> Dict[SplitType, List[Dict]]:
+    """Deterministic hash-based split."""
+    result = {SplitType.TRAIN: [], SplitType.VALIDATION: [], SplitType.TEST: []}
+
+    for item in items:
+        hash_val = hashlib.md5(
+            f"{json.dumps(item, sort_keys=True)}.burme".encode()
+        ).hexdigest()
+        hash_num = int(hash_val[:8], 16)
+        normalized = hash_num / 0xFFFFFFFF
+
+        if normalized < config.train_ratio:
+            result[SplitType.TRAIN].append(item)
+        elif normalized < config.train_ratio + config.val_ratio:
+            result[SplitType.VALIDATION].append(item)
+        else:
+            result[SplitType.TEST].append(item)
+
+    return result
+
+
+def main():
+    """Split dataset."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Split Burme-Coder-Max Dataset")
+    parser.add_argument("input", help="Input JSONL file")
+    parser.add_argument("-o", "--output-dir", default="data/split", help="Output directory")
+    parser.add_argument("--train-ratio", type=float, default=0.7, help="Train ratio")
+    parser.add_argument("--val-ratio", type=float, default=0.15, help="Validation ratio")
+    parser.add_argument("--test-ratio", type=float, default=0.15, help="Test ratio")
+    parser.add_argument("--seed", type=int, default=42, help="Random seed")
+    parser.add_argument("--hash", action="store_true", help="Use hash-based split")
+
+    args = parser.parse_args()
+
+    print("=" * 60)
+    print("✂️ Dataset Splitter")
+    print("=" * 60)
+
+    # Load data
+    print(f"\n📥 Loading: {args.input}")
+    items = load_jsonl(args.input)
+    print(f"   Loaded {len(items)} items")
+
+    # Configure split
+    config = SplitConfig(
+        train_ratio=args.train_ratio,
+        val_ratio=args.val_ratio,
+        test_ratio=args.test_ratio,
+        seed=args.seed,
+        hash_split=args.hash
+    )
+
+    # Split
+    print("\n✂️ Splitting dataset...")
+    splits = split_dataset(items, config)
+
+    for split_type, split_items in splits.items():
+        print(f"   {split_type.value}: {len(split_items)} items")
+
+    # Save splits
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    print(f"\n💾 Saving to: {output_dir}")
+    for split_type, split_items in splits.items():
+        output_file = output_dir / f"{split_type.value}.jsonl"
+        save_jsonl(str(output_file), split_items)
+        print(f"   ✅ {output_file.name}: {len(split_items)} items")
+
+    print("\n" + "=" * 60)
+    print("✅ Split complete!")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

scripts/validate_dataset.py

@@ -0,0 +1,249 @@
+"""Dataset Validation Script
+
+Validates burme-coder-max dataset quality and format.
+"""
+
+import json
+import re
+from pathlib import Path
+from typing import Dict, List, Tuple
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass
+class ValidationError:
+    """Validation error."""
+    line: int
+    field: str
+    message: str
+    severity: str = "error"
+
+
+class DatasetValidator:
+    """Validate the burme-coder-max dataset."""
+
+    # Validation rules
+    REQUIRED_FIELDS = ["system", "instruction", "response"]
+    MIN_RESPONSE_LENGTH = 20
+    MAX_RESPONSE_LENGTH = 10000
+    MIN_INSTRUCTION_LENGTH = 3
+
+    # Myanmar text pattern
+    MYANMAR_PATTERN = re.compile(r"[\u1000-\u109f\uAA60-\uAA7f]+")
+
+    def __init__(self, data_dir: str):
+        self.data_dir = Path(data_dir)
+        self.errors: List[ValidationError] = []
+        self.warnings: List[ValidationError] = []
+
+    def validate_file(self, file_path: str) -> Tuple[bool, List[Dict]]:
+        """Validate a single data file."""
+        items = []
+        self.errors = []
+        self.warnings = []
+
+        with open(file_path, "r", encoding="utf-8") as f:
+            for line_num, line in enumerate(f, 1):
+                if not line.strip():
+                    continue
+
+                try:
+                    item = json.loads(line)
+                    items.append(item)
+                    self._validate_item(item, line_num)
+                except json.JSONDecodeError as e:
+                    self.errors.append(ValidationError(
+                        line=line_num,
+                        field="json",
+                        message=f"Invalid JSON: {e}",
+                        severity="error"
+                    ))
+
+        return len(self errors) == 0, items
+
+    def _validate_item(self, item: Dict, line_num: int):
+        """Validate a single item."""
+        # Check required fields
+        for field in self.REQUIRED_FIELDS:
+            if field not in item:
+                self.errors.append(ValidationError(
+                    line=line_num,
+                    field=field,
+                    message=f"Missing required field: {field}",
+                    severity="error"
+                ))
+                return
+            elif not isinstance(item[field], str):
+                self.errors.append(ValidationError(
+                    line=line_num,
+                    field=field,
+                    message=f"Field {field} must be string",
+                    severity="error"
+                ))
+
+        # Check field lengths
+        response_len = len(item["response"])
+        if response_len < self.MIN_RESPONSE_LENGTH:
+            self.warnings.append(ValidationError(
+                line=line_num,
+                field="response",
+                message=f"Response too short ({response_len} chars)",
+                severity="warning"
+            ))
+
+        if response_len > self.MAX_RESPONSE_LENGTH:
+            self.warnings.append(ValidationError(
+                line=line_num,
+                field="response",
+                message=f"Response too long ({response_len} chars)"
+            ))
+
+        instruction_len = len(item["instruction"])
+        if instruction_len < self.MIN_INSTRUCTION_LENGTH:
+            self.errors.append(ValidationError(
+                line=line_num,
+                field="instruction",
+                message=f"Instruction too short ({instruction_len} chars)"
+            ))
+
+        # Check for code blocks
+        if "```" not in item["response"]:
+            self.warnings.append(ValidationError(
+                line=line_num,
+                field="response",
+                message="Response missing code block"
+            ))
+
+        # Check for language consistency
+        instruction_text = item["instruction"].lower()
+        response_text = item["response"]
+
+        # Count code blocks by language
+        code_blocks = re.findall(r"```(\w*)", response_text)
+        languages = set(code_blocks)
+
+        # Suggestion: if instruction mentions a language, include it in response
+        for lang in ["python", "javascript", "typescript", "java", "sql", "go", "rust"]:
+            if lang in instruction_text and lang.lower() not in languages:
+                self.warnings.append(ValidationError(
+                    line=line_num,
+                    field="response",
+                    message=f"Instruction mentions '{lang}' but no code block found"
+                ))
+
+    def get_stats(self, items: List[Dict]) -> Dict:
+        """Get dataset statistics."""
+        stats = {
+            "total_items": len(items),
+            "timestamp": datetime.now().isoformat(),
+        }
+
+        if not items:
+            return stats
+
+        # Length statistics
+        response_lengths = [len(item["response"]) for item in items]
+        instruction_lengths = [len(item["instruction"]) for item in items]
+
+        stats["response"] = {
+            "avg_length": sum(response_lengths) / len(response_lengths),
+            "min_length": min(response_lengths),
+            "max_length": max(response_lengths),
+        }
+
+        stats["instruction"] = {
+            "avg_length": sum(instruction_lengths) / len(instruction_lengths),
+            "min_length": min(instruction_lengths),
+            "max_length": max(instruction_lengths),
+        }
+
+        # Language distribution
+        all_languages = []
+        for item in items:
+            code_blocks = re.findall(r"```(\w*)", item["response"])
+            all_languages.extend([lang for lang in code_blocks if lang])
+
+        from collections import Counter
+        lang_counts = Counter(all_languages)
+        stats["languages"] = dict(lang_counts)
+
+        # Myanmar content
+        myanmar_count = sum(
+            1 for item in items
+            if self.MYANMAR_PATTERN.search(item["instruction"])
+        )
+        stats["myanmar_items"] = myanmar_count
+        stats["myanmar_percentage"] = (myanmar_count / len(items)) * 100 if items else 0
+
+        # System prompts
+        systems = set(item["system"] for item in items)
+        stats["unique_systems"] = len(systems)
+
+        return stats
+
+
+def main():
+    """Run validation."""
+    import sys
+
+    print("=" * 60)
+    print("📊 Burme-Coder-Max Dataset Validator")
+    print("=" * 60)
+
+    data_dir = Path(__file__).parent.parent / "data" / "knowledge"
+    validator = DatasetValidator(str(data_dir))
+
+    # Find JSONL files
+    jsonl_files = list(Path(".").rglob("*.jsonl"))
+    if not jsonl_files:
+        print("⚠️ No JSONL files found")
+        sys.exit(1)
+
+    total_errors = 0
+    total_warnings = 0
+    total_items = 0
+
+    for jsonl_file in jsonl_files:
+        print(f"\n📁 Validating: {jsonl_file.name}")
+
+        valid, items = validator.validate_file(str(jsonl_file))
+        total_items += len(items)
+
+        if validator.errors:
+            print(f"  ❌ {len(validator.errors)} errors:")
+            for err in validator.errors[:10]:
+                print(f"     Line {err.line}: {err.field} - {err.message}")
+
+        if validator.warnings:
+            print(f"  ⚠️ {len(validator.warnings)} warnings:")
+            for warn in validator.warnings[:5]:
+                print(f"     Line {warn.line}: {warn.field} - {warn.message}")
+
+        if valid and not validator.errors:
+            print("  ✅ Valid")
+
+        total_errors += len(validator.errors)
+        total_warnings += len(validator.warnings)
+
+    # Get overall stats
+    if jsonl_files:
+        validator.validate_file(str(jsonl_files[0]))
+        stats = validator.get_stats([])
+        stats["total_items"] = total_items
+
+        print("\n📈 Overall Statistics:")
+        print(f"  Total items: {stats['total_items']}")
+        print(f"  Total errors: {total_errors}")
+        print(f"  Total warnings: {total_warnings}")
+
+    print("\n" + "=" * 60)
+    if total_errors == 0:
+        print("✅ Validation passed!")
+    else:
+        print(f"❌ {total_errors} errors found, {total_warnings} warnings")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()

src/data_processing.py

@@ -0,0 +1,323 @@
+"""Data Validation and Split Module
+
+Validates and splits datasets for training/validation/testing.
+"""
+
+import json
+import random
+import hashlib
+from pathlib import Path
+from typing import List, Dict, Tuple, Optional, Callable
+from dataclasses import dataclass
+from enum import Enum
+import re
+
+
+class SplitType(Enum):
+    """Dataset split types."""
+
+    TRAIN = "train"
+    VALIDATION = "validation"
+    TEST = "test"
+
+
+@dataclass
+class DatasetItem:
+    """Single dataset item."""
+
+    system: str
+    instruction: str
+    response: str
+    metadata: Dict
+
+
+@dataclass
+class ValidationResult:
+    """Validation result."""
+
+    valid: bool
+    errors: List[str]
+    warnings: List[str]
+
+
+class DataValidator:
+    """Validate dataset items."""
+
+    MIN_RESPONSE_LENGTH = 10
+    MAX_RESPONSE_LENGTH = 10000
+    MIN_INSTRUCTION_LENGTH = 3
+
+    @classmethod
+    def validate_item(cls, item: Dict) -> ValidationResult:
+        """Validate a single dataset item."""
+        errors = []
+        warnings = []
+
+        # Check required fields
+        required_fields = ["system", "instruction", "response"]
+        for field in required_fields:
+            if field not in item:
+                errors.append(f"Missing required field: {field}")
+            elif not isinstance(item[field], str):
+                errors.append(f"Field '{field}' must be a string")
+
+        if errors:
+            return ValidationResult(valid=False, errors=errors, warnings=warnings)
+
+        # Validate lengths
+        if len(item["response"]) < cls.MIN_RESPONSE_LENGTH:
+            errors.append(f"Response too short: {len(item['response'])} chars")
+
+        if len(item["response"]) > cls.MAX_RESPONSE_LENGTH:
+            warnings.append(f"Response very long: {len(item['response'])} chars")
+
+        if len(item["instruction"]) < cls.MIN_INSTRUCTION_LENGTH:
+            errors.append(f"Instruction too short: {len(item['instruction'])} chars")
+
+        # Check for code blocks
+        if "```" not in item["response"]:
+            warnings.append("Response contains no code blocks")
+
+        # Check for Myanmar content
+        myanmar_pattern = re.compile(r"[\u1000-\u109f]+")
+        has_myanmar = bool(myanmar_pattern.search(item["instruction"]))
+
+        if not has_myanmar and not has_myanmar:
+            warnings.append("No Myanmar text found")
+
+        return ValidationResult(
+            valid=len(errors) == 0,
+            errors=errors,
+            warnings=warnings
+        )
+
+    @classmethod
+    def validate_dataset(cls, items: List[Dict]) -> Tuple[List[Dict], List[Dict]]:
+        """Validate entire dataset, return valid and invalid items."""
+        valid = []
+        invalid = []
+
+        for item in items:
+            result = cls.validate_item(item)
+            if result.valid:
+                valid.append(item)
+            else:
+                invalid.append({**item, "validation_errors": result.errors})
+
+        return valid, invalid
+
+
+class DataSplitter:
+    """Split dataset into train/validation/test sets."""
+
+    def __init__(self, train_ratio: float = 0.7, val_ratio: float = 0.15, test_ratio: float = 0.15):
+        self.train_ratio = train_ratio
+        self.val_ratio = val_ratio
+        self.test_ratio = test_ratio
+
+        assert abs(train_ratio + val_ratio + test_ratio - 1.0) < 0.001, "Ratios must sum to 1.0"
+
+    def split(
+        self,
+        items: List[Dict],
+        stratify_by: Optional[Callable] = None
+    ) -> Dict[SplitType, List[Dict]]:
+        """Split dataset with optional stratification."""
+        if stratify_by:
+            return self._stratified_split(items, stratify_by)
+        else:
+            return self._random_split(items)
+
+    def _random_split(self, items: List[Dict]) -> Dict[SplitType, List[Dict]]:
+        """Randomly split dataset."""
+        shuffled = items.copy()
+        random.shuffle(shuffled)
+
+        total = len(shuffled)
+        train_size = int(total * self.train_ratio)
+        val_size = int(total * self.val_ratio)
+
+        return {
+            SplitType.TRAIN: shuffled[:train_size],
+            SplitType.VALIDATION: shuffled[train_size:train_size + val_size],
+            SplitType.TEST: shuffled[train_size + val_size:]
+        }
+
+    def _stratified_split(
+        self,
+        items: List[Dict],
+        stratify_by: Callable
+    ) -> Dict[SplitType, List[Dict]]:
+        """Split with stratification by a key function."""
+        buckets: Dict[str, List[Dict]] = {}
+
+        for item in items:
+            key = stratify_by(item)
+            if key not in buckets:
+                buckets[key] = []
+            buckets[key].append(item)
+
+        train_buckets = {k: [] for k in buckets}
+        val_buckets = {k: [] for k in buckets}
+        test_buckets = {k: [] for k in buckets}
+
+        for key, bucket_items in buckets.items():
+            random.shuffle(bucket_items)
+            total = len(bucket_items)
+            train_size = int(total * self.train_ratio)
+            val_size = int(total * self.val_ratio)
+
+            train_buckets[key] = bucket_items[:train_size]
+            val_buckets[key] = bucket_items[train_size:train_size + val_size]
+            test_buckets[key] = bucket_items[train_size + val_size:]
+
+        return {
+            SplitType.TRAIN: [item for bucket in train_buckets.values() for item in bucket],
+            SplitType.VALIDATION: [item for bucket in val_buckets.values() for item in bucket],
+            SplitType.TEST: [item for bucket in test_buckets.values() for item in bucket],
+        }
+
+    def hash_split(self, items: List[Dict], salt: str = "") -> Dict[SplitType, List[Dict]]:
+        """Split based on hash for reproducibility."""
+        result = {SplitType.TRAIN: [], SplitType.VALIDATION: [], SplitType.TEST: []}
+
+        for item in items:
+            hash_val = hashlib.md5(
+                f"{json.dumps(item, sort_keys=True)}{salt}".encode()
+            ).hexdigest()
+
+            hash_num = int(hash_val[:8], 16)
+            normalized = hash_num / 0xFFFFFFFF
+
+            if normalized < self.train_ratio:
+                result[SplitType.TRAIN].append(item)
+            elif normalized < self.train_ratio + self.val_ratio:
+                result[SplitType.VALIDATION].append(item)
+            else:
+                result[SplitType.TEST].append(item)
+
+        return result
+
+
+class DatasetManager:
+    """Manage dataset operations."""
+
+    @staticmethod
+    def load_jsonl(file_path: str) -> List[Dict]:
+        """Load data from JSONL file."""
+        items = []
+        with open(file_path, "r", encoding="utf-8") as f:
+            for line in f:
+                if line.strip():
+                    items.append(json.loads(line))
+        return items
+
+    @staticmethod
+    def save_jsonl(file_path: str, items: List[Dict]):
+        """Save data to JSONL file."""
+        Path(file_path).parent.mkdir(parents=True, exist_ok=True)
+        with open(file_path, "w", encoding="utf-8") as f:
+            for item in items:
+                f.write(json.dumps(item, ensure_ascii=False) + "\n")
+
+    @staticmethod
+    def load_json(file_path: str) -> List[Dict]:
+        """Load data from JSON file."""
+        with open(file_path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            return data if isinstance(data, list) else data.get("data", data.get("items", [data]))
+
+    @staticmethod
+    def save_json(file_path: str, items: List[Dict]):
+        """Save data to JSON file."""
+        Path(file_path).parent.mkdir(parents=True, exist_ok=True)
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(items, f, indent=2, ensure_ascii=False)
+
+    @staticmethod
+    def save_split(
+        output_dir: str,
+        splits: Dict[SplitType, List[Dict]],
+        format: str = "jsonl"
+    ):
+        """Save split datasets to files."""
+        output_path = Path(output_dir)
+        output_path.mkdir(parents=True, exist_ok=True)
+
+        for split_type, items in splits.items():
+            file_path = output_path / f"{split_type.value}.jsonl"
+            DatasetManager.save_jsonl(str(file_path), items)
+
+    @staticmethod
+    def get_dataset_stats(items: List[Dict]) -> Dict:
+        """Get statistics about a dataset."""
+        if not items:
+            return {"count": 0}
+
+        response_lengths = [len(item.get("response", "")) for item in items]
+        instruction_lengths = [len(item.get("instruction", "")) for item in items]
+
+        systems = [item.get("system", "") for item in items]
+        unique_systems = len(set(systems))
+
+        return {
+            "count": len(items),
+            "avg_response_length": sum(response_lengths) / len(response_lengths),
+            "min_response_length": min(response_lengths),
+            "max_response_length": max(response_lengths),
+            "avg_instruction_length": sum(instruction_lengths) / len(instruction_lengths),
+            "unique_systems": unique_systems,
+        }
+
+
+def main():
+    """Demo the data validation and split module."""
+    print("=" * 50)
+    print("📊 Data Validation and Split Demo")
+    print("=" * 50)
+
+    # Sample data
+    sample_data = [
+        {
+            "system": "Expert Python programmer",
+            "instruction": "Python decorator hta ya py",
+            "response": "# Python Decorator\n```python\ndef decorator(func):\n    return func\n```"
+        },
+        {
+            "system": "Expert JavaScript developer",
+            "instruction": "JavaScript async/await hta ya",
+            "response": "// Async/Await\nasync function fetch() {\n    const data = await fetch('/api');\n}"
+        },
+        {
+            "system": "Database expert",
+            "instruction": "SQL JOIN operations",
+            "response": "-- SQL JOIN\nSELECT * FROM a INNER JOIN b ON a.id = b.id;"
+        },
+    ] * 10  # Multiply for demo
+
+    print(f"\n📁 Sample data: {len(sample_data)} items")
+
+    # Validate
+    print("\n🔍 Validating data...")
+    validator = DataValidator()
+    valid, invalid = validator.validate_dataset(sample_data)
+    print(f"  ✓ Valid: {len(valid)}")
+    print(f"  ✗ Invalid: {len(invalid)}")
+
+    # Split
+    print("\n✂️ Splitting data (70/15/15)...")
+    splitter = DataSplitter()
+    splits = splitter.hash_split(sample_data, salt="burme-coder-v1")
+
+    for split_type, items in splits.items():
+        print(f"  {split_type.value}: {len(items)} items")
+
+    # Stats
+    print("\n📈 Dataset statistics:")
+    stats = DatasetManager.get_dataset_stats(valid)
+    for key, value in stats.items():
+        print(f"  {key}: {value:.2f}" if isinstance(value, float) else f"  {key}: {value}")
+
+
+if __name__ == "__main__":
+    main()

tests/test_qa.py

@@ -0,0 +1,352 @@
+"""Quality Assurance Testing Suite
+
+Comprehensive QA tests for burme-coder-max project.
+Covers: Code Quality, Functionality, Performance, Security.
+"""
+
+import pytest
+import ast
+import os
+import re
+import sys
+from pathlib import Path
+from typing import List, Dict, Tuple
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+
+class TestCodeQuality:
+    """Code quality validation tests."""
+
+    PROJECT_ROOT = Path(__file__).parent.parent
+
+    def test_python_syntax(self):
+        """Verify all Python files have valid syntax."""
+        errors = []
+        for py_file in self.PROJECT_ROOT.rglob("*.py"):
+            if ".venv" in str(py_file) or "venv" in str(py_file):
+                continue
+            try:
+                content = py_file.read_text(encoding="utf-8")
+                ast.parse(content)
+            except SyntaxError as e:
+                errors.append(f"{py_file}: {e}")
+
+        assert not errors, f"Syntax errors found:\n" + "\n".join(errors)
+
+    def test_docstrings_present(self):
+        """Check module-level docstrings exist."""
+        missing_docs = []
+        for py_file in (self.PROJECT_ROOT / "src").rglob("*.py"):
+            if py_file.name == "__init__.py":
+                continue
+            content = py_file.read_text(encoding="utf-8")
+            if '"""' not in content and "'''" not in content:
+                missing_docs.append(py_file.name)
+
+        assert not missing_docs, f"Missing docstrings in: {missing_docs}"
+
+    def test_imports_are_valid(self):
+        """Verify all imports can be resolved."""
+        for py_file in (self.PROJECT_ROOT / "src").rglob("*.py"):
+            content = py_file.read_text(encoding="utf-8")
+            tree = ast.parse(content)
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    for alias in node.names:
+                        # Skip relative imports and external packages
+                        if not alias.name.startswith(".") and not alias.name.startswith("_"):
+                            pass  # External packages assumed valid
+                elif isinstance(node, ast.ImportFrom):
+                    module = node.module or ""
+                    if module.startswith("_"):
+                        pytest.fail(f"Import from private module: {module} in {py_file}")
+
+    def test_no_debug_code(self):
+        """Check for debug/ad-hoc code."""
+        debug_patterns = [
+            r"print\s*\(\s*debug",
+            r"print\s*\(\s*TODO",
+            r"print\s*\(\s*FIXME",
+            r"print\s*\(\s*console\.log",
+            r"import\s+pdb",
+            r"import\s+ipdb",
+        ]
+        violations = []
+        for py_file in (self.PROJECT_ROOT / "src").rglob("*.py"):
+            content = py_file.read_text(encoding="utf-8")
+            for pattern in debug_patterns:
+                if re.search(pattern, content, re.IGNORECASE):
+                    violations.append(f"{py_file.name}: {pattern}")
+
+        assert not violations, f"Debug code found:\n{violations}"
+
+
+class TestFunctionality:
+    """Functional tests for core modules."""
+
+    def test_agent_initialization(self):
+        """Test CoderAgent can be initialized."""
+        from core.agent import CoderAgent
+        agent = CoderAgent()
+        assert agent is not None
+        assert agent.model == "gpt-4"
+        assert agent.session_id is not None
+
+    def test_agent_generate_response(self):
+        """Test response generation returns expected structure."""
+        from core.agent import CoderAgent
+        agent = CoderAgent()
+        response = agent.generate_response("test instruction")
+
+        assert "session_id" in response
+        assert "instruction" in response
+        assert "response" in response
+        assert "timestamp" in response
+        assert "model" in response
+
+    def test_executor_initialization(self):
+        """Test CodeExecutor initialization."""
+        from core.executor import CodeExecutor, ExecutionResult
+        executor = CodeExecutor(timeout=10)
+        assert executor.timeout == 10
+        assert executor.execution_count == 0
+
+    def test_validator_initialization(self):
+        """Test ResponseValidator initialization."""
+        from core.validator import ResponseValidator, ValidationResult
+        validator = ResponseValidator()
+        result = validator.validate("def test(): pass", "test function")
+
+        assert isinstance(result, ValidationResult)
+        assert hasattr(result, "quality")
+        assert hasattr(result, "score")
+        assert hasattr(result, "issues")
+
+    def test_animation_configs(self):
+        """Test all animation classes are importable."""
+        from animations import Spinner, ProgressBar, ParticleBurst, TypingEffect
+        assert Spinner is not None
+        assert ProgressBar is not None
+        assert ParticleBurst is not None
+        assert TypingEffect is not None
+
+    def test_knowledge_base_search(self):
+        """Test LocalKB search functionality."""
+        from knowledge import LocalKB
+        kb = LocalKB()
+        results = kb.search("python")
+        assert isinstance(results, list)
+
+
+class TestSecurity:
+    """Security validation tests."""
+
+    PROJECT_ROOT = Path(__file__).parent.parent
+
+    def test_no_hardcoded_secrets(self):
+        """Check for hardcoded passwords/secrets in code."""
+        secret_patterns = [
+            r"password\s*=\s*['\"][^'\"]{8,}['\"]",
+            r"api_key\s*=\s*['\"][^'\"]{20,}['\"]",
+            r"secret\s*=\s*['\"][^'\"]{20,}['\"]",
+            r"token\s*=\s*['\"][A-Za-z0-9_\-]{30,}['\"]",
+        ]
+        violations = []
+        for py_file in (self.PROJECT_ROOT / "src").rglob("*.py"):
+            content = py_file.read_text(encoding="utf-8")
+            for pattern in secret_patterns:
+                if re.search(pattern, content, re.IGNORECASE):
+                    violations.append(f"{py_file.name}")
+
+        assert not violations, f"Hardcoded secrets found in: {violations}"
+
+    def test_sql_injection_protection(self):
+        """Verify SQL queries use parameterized inputs."""
+        dangerous_sql = ["SELECT * FROM users WHERE name = '" + "' + user_input + '"]
+        violations = []
+        for py_file in (self.PROJECT_ROOT / "src").rglob("*.py"):
+            content = py_file.read_text(encoding="utf-8")
+            if "sql" in content.lower() or "query" in content.lower():
+                for dangerous in dangerous_sql:
+                    if dangerous in content:
+                        violations.append(py_file.name)
+
+        assert not violations, f"SQL injection vulnerable code: {violations}"
+
+    def test_shell_injection_protection(self):
+        """Verify shell commands are safe."""
+        from core.executor import CodeExecutor
+        executor = CodeExecutor()
+
+        # Should detect potentially malicious code
+        malicious = "__import__('os').system('rm -rf /')"
+        result = executor._contains_malicious_code(malicious)
+        assert result == True
+
+    def test_input_validation(self):
+        """Test input validation in key modules."""
+        from core.validator import ResponseValidator
+
+        # Empty response should still validate
+        validator = ResponseValidator()
+        result = validator.validate("", "test")
+        assert result.score >= 0  # Score should be defined
+
+
+class TestPerformance:
+    """Performance-related tests."""
+
+    def test_import_time(self):
+        """Measure import time for core modules."""
+        import time
+
+        start = time.time()
+        from core.agent import CoderAgent
+        from core.executor import CodeExecutor
+        from core.validator import ResponseValidator
+        import_duration = time.time() - start
+
+        # Should import in under 2 seconds
+        assert import_duration < 2.0, f"Import took {import_duration}s"
+
+    def test_agent_response_time(self):
+        """Test response generation time."""
+        import time
+        from core.agent import CoderAgent
+
+        agent = CoderAgent()
+        start = time.time()
+        response = agent.generate_response("test")
+        duration = time.time() - start
+
+        # Should complete in reasonable time
+        assert duration < 5.0, f"Response took {duration}s"
+
+
+class TestIntegration:
+    """Integration tests across modules."""
+
+    def test_full_agent_workflow(self):
+        """Test complete agent workflow."""
+        from core.agent import CoderAgent
+        from core.validator import ResponseValidator
+
+        agent = CoderAgent()
+        validator = ResponseValidator()
+
+        instruction = "Write a Python hello world function"
+        response = agent.generate_response(instruction)
+        validation = validator.validate(response["response"], instruction)
+
+        assert validation.score > 0
+        assert len(response["response"]) > 0
+
+    def test_animation_with_agent(self):
+        """Test animations working with agent."""
+        import time
+        from animations import Spinner
+        from core.agent import CoderAgent
+
+        agent = CoderAgent()
+        with Spinner("Testing..."):
+            response = agent.generate_response("test")
+            time.sleep(0.1)
+
+        assert len(response["response"]) > 0
+
+    def test_knowledge_with_agent(self):
+        """Test knowledge base integration."""
+        from core.agent import CoderAgent
+        from knowledge import LocalKB
+
+        agent = CoderAgent()
+        kb = LocalKB()
+
+        # Create agent with knowledge dir
+        agent_with_kb = CoderAgent(
+            knowledge_dir=str(Path(__file__).parent.parent / "data" / "knowledge")
+        )
+        response = agent_with_kb.generate_response("python decorator hta ya")
+
+        assert len(response["response"]) > 0
+
+
+class TestDocumentation:
+    """Documentation quality tests."""
+
+    PROJECT_ROOT = Path(__file__).parent.parent
+
+    def test_readme_exists(self):
+        """Verify README.md exists."""
+        readme = self.PROJECT_ROOT / "README.md"
+        assert readme.exists(), "README.md not found"
+
+    def test_readme_has_install_section(self):
+        """Check README has installation instructions."""
+        readme = (self.PROJECT_ROOT / "README.md").read_text(encoding="utf-8")
+        assert "install" in readme.lower(), "Install section missing"
+
+    def test_readme_has_usage_section(self):
+        """Check README has usage examples."""
+        readme = (self.PROJECT_ROOT / "README.md").read_text(encoding="utf-8")
+        assert "usage" in readme.lower() or "example" in readme.lower()
+
+    def test_docs_directory_exists(self):
+        """Verify docs directory exists."""
+        docs_dir = self.PROJECT_ROOT / "docs"
+        assert docs_dir.exists(), "docs/ directory not found"
+
+    def test_all_md_files_have_content(self):
+        """Check all markdown files have substantial content."""
+        small_files = []
+        for md_file in self.PROJECT_ROOT.rglob("*.md"):
+            content = md_file.read_text(encoding="utf-8")
+            if len(content) < 100:
+                small_files.append(md_file.name)
+
+        assert not small_files, f"Very short markdown files: {small_files}"
+
+
+class QAReport:
+    """Generate QA report."""
+
+    CLASSES = [
+        TestCodeQuality,
+        TestFunctionality,
+        TestSecurity,
+        TestPerformance,
+        TestIntegration,
+        TestDocumentation,
+    ]
+
+    @classmethod
+    def run_all(cls) -> Dict:
+        """Run all test classes and generate report."""
+        from collections import defaultdict
+
+        results = defaultdict(list)
+        for test_class in cls.CLASSES:
+            class_name = test_class.__name__
+            for method_name in dir(test_class):
+                if method_name.startswith("test_"):
+                    try:
+                        instance = test_class()
+                        method = getattr(instance, method_name)
+                        method()
+                        results[class_name].append({
+                            "name": method_name,
+                            "status": "PASS"
+                        })
+                    except Exception as e:
+                        results[class_name].append({
+                            "name": method_name,
+                            "status": "FAIL",
+                            "error": str(e)
+                        })
+
+        return dict(results)
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v", "--tb=short"])