main.yml

# 🚀 Neural Nexus - CI/CD Pipeline
name: Neural Nexus CI/CD

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main, develop ]
  release:
    types: [published]

env:
  CARGO_TERM_COLOR: always
  RUST_BACKTRACE: 1

jobs:
  # 🧪 Testing Jobs
  test-rust:
    name: 🦀 Rust Tests
    runs-on: ubuntu-latest
    strategy:
      matrix:
        rust-version: [stable, beta]
    
    steps:
    - uses: actions/checkout@v4
    
    - name: Install Rust toolchain
      uses: actions-rs/toolchain@v1
      with:
        toolchain: ${{ matrix.rust-version }}
        profile: minimal
        override: true
        components: rustfmt, clippy
    
    - name: Cache cargo registry
      uses: actions/cache@v3
      with:
        path: ~/.cargo/registry
        key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
    
    - name: Cache cargo index
      uses: actions/cache@v3
      with:
        path: ~/.cargo/git
        key: ${{ runner.os }}-cargo-index-${{ hashFiles('**/Cargo.lock') }}
    
    - name: Cache cargo build
      uses: actions/cache@v3
      with:
        path: target
        key: ${{ runner.os }}-cargo-build-target-${{ hashFiles('**/Cargo.lock') }}
    
    - name: Check formatting
      run: cargo fmt --all -- --check
    
    - name: Run clippy
      run: cargo clippy --all-targets --all-features -- -D warnings
    
    - name: Run tests
      run: cargo test --all-features --workspace
    
    - name: Run benchmarks
      run: cargo bench --no-run

  test-python:
    name: 🐍 Python Tests
    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@v4
      with:
        python-version: ${{ matrix.python-version }}
    
    - name: Cache pip packages
      uses: actions/cache@v3
      with:
        path: ~/.cache/pip
        key: ${{ runner.os }}-pip-${{ hashFiles('**/pyproject.toml') }}
        restore-keys: |
          ${{ runner.os }}-pip-
    
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -e .[dev]
    
    - name: Run black
      run: black --check .
    
    - name: Run isort
      run: isort --check-only .
    
    - name: Run flake8
      run: flake8 .
    
    - name: Run mypy
      run: mypy .
    
    - name: Run tests
      run: pytest --cov=neural_nexus --cov-report=xml
    
    - name: Upload coverage to Codecov
      uses: codecov/codecov-action@v3
      with:
        file: ./coverage.xml
        flags: python
        name: codecov-umbrella

  # 🏗️ Build Jobs
  build-rust:
    name: 🦀 Rust Build
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
        target: [x86_64-unknown-linux-gnu, aarch64-unknown-linux-gnu, x86_64-pc-windows-msvc, x86_64-apple-darwin]
        exclude:
          - os: ubuntu-latest
            target: x86_64-pc-windows-msvc
          - os: ubuntu-latest
            target: x86_64-apple-darwin
          - os: windows-latest
            target: x86_64-unknown-linux-gnu
          - os: windows-latest
            target: aarch64-unknown-linux-gnu
          - os: windows-latest
            target: x86_64-apple-darwin
          - os: macos-latest
            target: x86_64-unknown-linux-gnu
          - os: macos-latest
            target: aarch64-unknown-linux-gnu
          - os: macos-latest
            target: x86_64-pc-windows-msvc
    
    steps:
    - uses: actions/checkout@v4
    
    - name: Install Rust toolchain
      uses: actions-rs/toolchain@v1
      with:
        toolchain: stable
        target: ${{ matrix.target }}
        override: true
    
    - name: Install cross-compilation tools
      if: matrix.target == 'aarch64-unknown-linux-gnu'
      run: |
        sudo apt-get update
        sudo apt-get install -y gcc-aarch64-linux-gnu
    
    - name: Build
      uses: actions-rs/cargo@v1
      with:
        command: build
        args: --release --target ${{ matrix.target }}
    
    - name: Upload artifacts
      uses: actions/upload-artifact@v4
      with:
        name: neural-nexus-${{ matrix.target }}
        path: target/${{ matrix.target }}/release/neural-nexus-*

  # 🐳 Docker Build
  build-docker:
    name: 🐳 Docker Build
    runs-on: ubuntu-latest
    needs: [test-rust, test-python]
    
    steps:
    - uses: actions/checkout@v4
    
    - name: Set up Docker Buildx
      uses: docker/setup-buildx-action@v2
    
    - name: Login to DockerHub
      if: github.event_name != 'pull_request'
      uses: docker/login-action@v2
      with:
        username: ${{ secrets.DOCKERHUB_USERNAME }}
        password: ${{ secrets.DOCKERHUB_TOKEN }}
    
    - name: Extract metadata
      id: meta
      uses: docker/metadata-action@v4
      with:
        images: neuralnexus/core-system
        tags: |
          type=ref,event=branch
          type=ref,event=pr
          type=semver,pattern={{version}}
          type=semver,pattern={{major}}.{{minor}}
          type=raw,value=latest,enable={{is_default_branch}}
    
    - name: Build and push orchestrator
      uses: docker/build-push-action@v6
      with:
        context: .
        file: ./Dockerfile.orchestrator
        push: ${{ github.event_name != 'pull_request' }}
        tags: ${{ steps.meta.outputs.tags }}-orchestrator
        labels: ${{ steps.meta.outputs.labels }}
        cache-from: type=gha
        cache-to: type=gha,mode=max
    
    - name: Build and push node
      uses: docker/build-push-action@v6
      with:
        context: .
        file: ./Dockerfile.node
        push: ${{ github.event_name != 'pull_request' }}
        tags: ${{ steps.meta.outputs.tags }}-node
        labels: ${{ steps.meta.outputs.labels }}
        cache-from: type=gha
        cache-to: type=gha,mode=max

  # 🎯 Edge Device Testing
  test-edge-devices:
    name: 🎯 Edge Device Tests
    runs-on: ubuntu-latest
    strategy:
      matrix:
        device: [raspberry-pi, jetson, generic]
    
    steps:
    - uses: actions/checkout@v4
    
    - name: Set up QEMU
      uses: docker/setup-qemu-action@v2
    
    - name: Set up Docker Buildx
      uses: docker/setup-buildx-action@v2
    
    - name: Build edge image
      run: |
        docker buildx build \
          --platform linux/arm64,linux/amd64 \
          --file Dockerfile.edge \
          --build-arg DEVICE_TYPE=${{ matrix.device }} \
          --tag neuralnexus/edge-${{ matrix.device }}:test \
          --load .
    
    - name: Test edge functionality
      run: |
        docker run --rm \
          -e DEVICE_TYPE=${{ matrix.device }} \
          -e TEST_MODE=true \
          neuralnexus/edge-${{ matrix.device }}:test \
          pytest tests/edge/test_${{ matrix.device }}.py

  # 🚀 Deployment
  deploy:
    name: 🚀 Deploy
    runs-on: ubuntu-latest
    needs: [test-rust, test-python, build-docker]
    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
    
    steps:
    - uses: actions/checkout@v4
    
    - name: Deploy to staging
      run: |
        echo "Deploying to staging environment..."
        # Add deployment commands here
    
    - name: Run integration tests
      run: |
        echo "Running integration tests..."
        # Add integration test commands here
    
    - name: Deploy to production
      if: success()
      run: |
        echo "Deploying to production environment..."
        # Add production deployment commands here

  # 📊 Performance Benchmarks
  benchmark:
    name: 📊 Performance Benchmarks
    runs-on: ubuntu-latest
    needs: [test-rust]
    
    steps:
    - uses: actions/checkout@v4
    
    - name: Install Rust toolchain
      uses: actions-rs/toolchain@v1
      with:
        toolchain: stable
        profile: minimal
        override: true
    
    - name: Cache cargo
      uses: actions/cache@v3
      with:
        path: |
          ~/.cargo/registry
          ~/.cargo/git
          target
        key: ${{ runner.os }}-cargo-bench-${{ hashFiles('**/Cargo.lock') }}
    
    - name: Run benchmarks
      run: cargo bench --all-features
    
    - name: Store benchmark results
      uses: benchmark-action/github-action-benchmark@v1
      with:
        name: Neural Nexus Benchmarks
        tool: 'cargo'
        output-file-path: target/criterion/report/index.html
        github-token: ${{ secrets.GITHUB_TOKEN }}
        auto-push: true

  # 🔒 Security Audit
  security-audit:
    name: 🔒 Security Audit
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v4
    
    - name: Rust security audit
      uses: actions-rs/audit@v1
      with:
        token: ${{ secrets.GITHUB_TOKEN }}
    
    - name: Python security audit
      run: |
        pip install safety
        safety check --json --output security-report.json || true
    
    - name: Upload security report
      uses: actions/upload-artifact@v4
      with:
        name: security-report
        path: security-report.json

  # 📈 Code Quality
  code-quality:
    name: 📈 Code Quality
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v4
      with:
        fetch-depth: 0
    
    - name: SonarCloud Scan
      uses: SonarSource/sonarcloud-github-action@master
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
    
    - name: CodeQL Analysis
      uses: github/codeql-action/init@v2
      with:
        languages: rust, python
    
    - name: Autobuild
      uses: github/codeql-action/autobuild@v2
    
    - name: Perform CodeQL Analysis
      uses: github/codeql-action/analyze@v2

  # 📱 Mobile/Edge Compatibility
  cross-platform-test:
    name: 📱 Cross-Platform Test
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
        python-version: [3.8, 3.11]
    
    steps:
    - uses: actions/checkout@v4
    
    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: ${{ matrix.python-version }}
    
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -e .[dev]
    
    - name: Run cross-platform tests
      run: pytest tests/cross_platform/

  # 🏷️ Release
  release:
    name: 🏷️ Create Release
    runs-on: ubuntu-latest
    needs: [test-rust, test-python, build-docker, security-audit]
    if: github.event_name == 'release'
    
    steps:
    - uses: actions/checkout@v4
    
    - name: Download artifacts
      uses: actions/download-artifact@v3
    
    - name: Create release assets
      run: |
        mkdir -p release-assets
        cp neural-nexus-*/neural-nexus-* release-assets/
    
    - name: Upload release assets
      uses: softprops/action-gh-release@v1
      with:
        files: release-assets/*
        generate_release_notes: true
      env:
        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

  # 📚 Documentation
  docs:
    name: 📚 Build Documentation
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v4
    
    - name: Set up Python
      uses: actions/setup-python@v4
      with:
        python-version: 3.11
    
    - name: Install dependencies
      run: |
        pip install mkdocs mkdocs-material mkdocs-mermaid2-plugin
    
    - name: Build docs
      run: mkdocs build
    
    - name: Deploy docs
      if: github.ref == 'refs/heads/main'
      run: mkdocs gh-deploy --force