part6-deployment.ps1

# ALGODON Part 6: Deployment & CI/CD
# This script creates Docker, Kubernetes, and CI/CD configurations

Write-Host "🚀 ALGODON Part 6: Deployment & CI/CD" -ForegroundColor Cyan

Set-Location "ALGODON"

# Generate Docker Compose file
$dockerCompose = @'
version: '3.8'

services:
  web:
    build:
      context: ./web
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=development
      - ORACLE_CONNECTION_STRING=oracle://algodon:password@oracle-db:1521/XE
      - REDIS_URL=redis://redis:6379
      - NEXT_PUBLIC_APP_URL=http://localhost:3000
    depends_on:
      - oracle-db
      - redis
    volumes:
      - ./web:/app
      - /app/node_modules
      - /app/.next
    networks:
      - algodon-network

  oracle-db:
    image: container-registry.oracle.com/database/express:21.3.0-xe
    ports:
      - "1521:1521"
      - "5500:5500"
    environment:
      - ORACLE_PWD=password
      - ORACLE_CHARACTERSET=AL32UTF8
    volumes:
      - oracle-data:/opt/oracle/oradata
    networks:
      - algodon-network
    healthcheck:
      test: ["CMD", "sqlplus", "-L", "algodon/password@localhost:1521/XE", "-e", "SELECT 1 FROM DUAL"]
      interval: 30s
      timeout: 10s
      retries: 5

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    networks:
      - algodon-network
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  postgres:
    image: postgres:15-alpine
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_USER=algodon
      - POSTGRES_PASSWORD=password
      - POSTGRES_DB=algodon_analytics
    volumes:
      - postgres-data:/var/lib/postgresql/data
    networks:
      - algodon-network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U algodon"]
      interval: 10s
      timeout: 5s
      retries: 5

  minio:
    image: minio/minio:latest
    ports:
      - "9000:9000"
      - "9001:9001"
    environment:
      - MINIO_ROOT_USER=minioadmin
      - MINIO_ROOT_PASSWORD=minioadmin
    volumes:
      - minio-data:/data
    command: server /data --console-address ":9001"
    networks:
      - algodon-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 20s
      retries: 3

volumes:
  oracle-data:
  redis-data:
  postgres-data:
  minio-data:

networks:
  algodon-network:
    driver: bridge
'@

$dockerCompose | Out-File -FilePath "deployment/docker/docker-compose.yml" -Encoding UTF8
Write-Host "✅ Created Docker Compose file" -ForegroundColor Green

# Generate web Dockerfile
$webDockerfile = @'
FROM node:20-alpine AS base

# Install dependencies only when needed
FROM base AS deps
RUN apk add --no-cache libc6-compat
WORKDIR /app

COPY web/package.json web/package-lock.json* ./
RUN npm ci

# Rebuild the source code only when needed
FROM base AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY web .

ENV NEXT_TELEMETRY_DISABLED 1

RUN npm run build

# Production image, copy all the files and run next
FROM base AS runner
WORKDIR /app

ENV NODE_ENV production
ENV NEXT_TELEMETRY_DISABLED 1

RUN addgroup --system --gid 1001 nodejs
RUN adduser --system --uid 1001 nextjs

COPY --from=builder /app/public ./public
COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static

USER nextjs

EXPOSE 3000

ENV PORT 3000
ENV HOSTNAME "0.0.0.0"

CMD ["node", "server.js"]
'@

$webDockerfile | Out-File -FilePath "web/Dockerfile" -Encoding UTF8

# Generate Kubernetes deployment
$k8sDeployment = @'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: algodon-web
  namespace: algodon
  labels:
    app: algodon-web
spec:
  replicas: 3
  selector:
    matchLabels:
      app: algodon-web
  template:
    metadata:
      labels:
        app: algodon-web
    spec:
      containers:
      - name: web
        image: ghcr.io/algodon/web:latest
        ports:
        - containerPort: 3000
        env:
        - name: NODE_ENV
          value: "production"
        - name: ORACLE_CONNECTION_STRING
          valueFrom:
            secretKeyRef:
              name: algodon-secrets
              key: oracle-connection-string
        - name: REDIS_URL
          valueFrom:
            secretKeyRef:
              name: algodon-secrets
              key: redis-url
        - name: STRIPE_SECRET_KEY
          valueFrom:
            secretKeyRef:
              name: algodon-secrets
              key: stripe-secret-key
        - name: OPENAI_API_KEY
          valueFrom:
            secretKeyRef:
              name: algodon-secrets
              key: openai-api-key
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1Gi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /api/health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /api/health
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: algodon-web
  namespace: algodon
spec:
  selector:
    app: algodon-web
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000
  type: LoadBalancer
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: algodon-ingress
  namespace: algodon
  annotations:
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - algodon.app
    - www.algodon.app
    secretName: algodon-tls
  rules:
  - host: algodon.app
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: algodon-web
            port:
              number: 80
  - host: www.algodon.app
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: algodon-web
            port:
              number: 80
'@

$k8sDeployment | Out-File -FilePath "deployment/kubernetes/web-deployment.yaml" -Encoding UTF8
Write-Host "✅ Created Kubernetes deployment" -ForegroundColor Green

# Generate GitHub Actions workflow
$githubActions = @'
name: CI/CD Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'
          cache-dependency-path: web/package-lock.json
      
      - name: Install dependencies
        run: |
          cd web
          npm ci
      
      - name: Run linter
        run: |
          cd web
          npm run lint
      
      - name: Run type check
        run: |
          cd web
          npm run type-check
      
      - name: Run tests
        run: |
          cd web
          npm test -- --coverage
      
      - name: Upload coverage
        uses: codecov/codecov-action@v3
        with:
          files: ./web/coverage/lcov.info

  build:
    needs: test
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write
    steps:
      - uses: actions/checkout@v4
      
      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3
      
      - name: Log in to Container Registry
        uses: docker/login-action@v3
        with:
          registry: ${{ env.REGISTRY }}
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}
      
      - name: Extract metadata
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}/web
          tags: |
            type=ref,event=branch
            type=ref,event=pr
            type=semver,pattern={{version}}
            type=semver,pattern={{major}}.{{minor}}
            type=sha,prefix={{branch}}-
      
      - name: Build and push Docker image
        uses: docker/build-push-action@v5
        with:
          context: ./web
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=gha
          cache-to: type=gha,mode=max

  deploy-staging:
    needs: build
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/develop'
    environment:
      name: staging
      url: https://staging.algodon.app
    steps:
      - uses: actions/checkout@v4
      
      - name: Configure kubectl
        uses: azure/setup-kubectl@v3
      
      - name: Set up Kubeconfig
        run: |
          echo "${{ secrets.KUBECONFIG_STAGING }}" | base64 -d > kubeconfig
          export KUBECONFIG=./kubeconfig
      
      - name: Deploy to staging
        run: |
          export KUBECONFIG=./kubeconfig
          kubectl set image deployment/algodon-web web=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}/web:develop-${{ github.sha }} -n algodon
          kubectl rollout status deployment/algodon-web -n algodon
      
      - name: Run smoke tests
        run: |
          sleep 30
          curl -f https://staging.algodon.app/api/health || exit 1

  deploy-production:
    needs: build
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    environment:
      name: production
      url: https://algodon.app
    steps:
      - uses: actions/checkout@v4
      
      - name: Configure kubectl
        uses: azure/setup-kubectl@v3
      
      - name: Set up Kubeconfig
        run: |
          echo "${{ secrets.KUBECONFIG_PRODUCTION }}" | base64 -d > kubeconfig
          export KUBECONFIG=./kubeconfig
      
      - name: Deploy to production (canary)
        run: |
          export KUBECONFIG=./kubeconfig
          # Deploy to 10% of traffic first
          kubectl set image deployment/algodon-web web=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}/web:main-${{ github.sha }} -n algodon
          kubectl rollout status deployment/algodon-web -n algodon --timeout=5m
      
      - name: Run smoke tests
        run: |
          sleep 60
          curl -f https://algodon.app/api/health || exit 1
      
      - name: Full rollout
        if: success()
        run: |
          export KUBECONFIG=./kubeconfig
          # Scale to 100% if canary successful
          kubectl scale deployment/algodon-web --replicas=5 -n algodon
          kubectl rollout status deployment/algodon-web -n algodon
'@

$githubActions | Out-File -FilePath "deployment/ci-cd/.github/workflows/ci-cd.yml" -Encoding UTF8
Write-Host "✅ Created GitHub Actions workflow" -ForegroundColor Green

# Generate health check API
$healthCheckApi = @'
import { NextRequest, NextResponse } from 'next/server';
import { getDbConnection } from '@/lib/db/oracle';
import { createClient } from 'redis';

export async function GET(req: NextRequest) {
  const checks: Record<string, string> = {};

  // Database check
  try {
    const connection = await getDbConnection();
    await connection.execute('SELECT 1 FROM DUAL');
    await connection.close();
    checks.database = 'healthy';
  } catch (error) {
    checks.database = 'unhealthy';
  }

  // Redis check
  try {
    const redis = createClient({ url: process.env.REDIS_URL });
    await redis.connect();
    await redis.ping();
    await redis.quit();
    checks.redis = 'healthy';
  } catch (error) {
    checks.redis = 'unhealthy';
  }

  const allHealthy = Object.values(checks).every((status) => status === 'healthy');

  return NextResponse.json(
    {
      status: allHealthy ? 'healthy' : 'degraded',
      checks,
      timestamp: new Date().toISOString(),
    },
    { status: allHealthy ? 200 : 503 }
  );
}
'@

$healthCheckApi | Out-File -FilePath "web/app/api/health/route.ts" -Encoding UTF8
Write-Host "✅ Created health check API" -ForegroundColor Green

# Generate deployment script
$deployScript = @'
# ALGODON Deployment Script
# Usage: .\deploy.ps1 [local|staging|production]

param(
    [Parameter(Mandatory=$true)]
    [ValidateSet("local", "staging", "production")]
    [string]$Environment
)

Write-Host "🚀 ALGODON Deployment - $Environment" -ForegroundColor Cyan

# Check prerequisites
$prerequisites = @{
    "Docker" = "docker"
    "Node.js" = "node"
    "npm" = "npm"
}

foreach ($prereq in $prerequisites.GetEnumerator()) {
    $command = Get-Command $prereq.Value -ErrorAction SilentlyContinue
    if (-not $command) {
        Write-Host "❌ $($prereq.Key) is not installed. Please install it first." -ForegroundColor Red
        exit 1
    }
    Write-Host "✅ $($prereq.Key) found: $($command.Version)" -ForegroundColor Green
}

switch ($Environment) {
    "local" {
        Write-Host "`n📦 Starting local development environment..." -ForegroundColor Yellow
        
        # Check if .env file exists
        if (-not (Test-Path "web\.env")) {
            Write-Host "⚠️  .env file not found. Creating from .env.example..." -ForegroundColor Yellow
            Copy-Item "web\.env.example" "web\.env"
            Write-Host "⚠️  Please update web\.env with your API keys!" -ForegroundColor Yellow
        }
        
        # Start Docker Compose
        Write-Host "`n🐳 Starting Docker containers..." -ForegroundColor Yellow
        Set-Location "deployment\docker"
        docker-compose up -d
        
        Write-Host "`n⏳ Waiting for services to be ready..." -ForegroundColor Yellow
        Start-Sleep -Seconds 30
        
        # Check health
        $maxRetries = 10
        $retryCount = 0
        $healthy = $false
        
        while ($retryCount -lt $maxRetries -and -not $healthy) {
            try {
                $response = Invoke-WebRequest -Uri "http://localhost:3000/api/health" -UseBasicParsing -ErrorAction Stop
                if ($response.StatusCode -eq 200) {
                    $healthy = $true
                }
            } catch {
                $retryCount++
                Write-Host "  Waiting for services... ($retryCount/$maxRetries)" -ForegroundColor Gray
                Start-Sleep -Seconds 5
            }
        }
        
        if ($healthy) {
            Write-Host "`n✅ Local environment is ready!" -ForegroundColor Green
            Write-Host "`n📍 Services:" -ForegroundColor Cyan
            Write-Host "   Web: http://localhost:3000" -ForegroundColor Yellow
            Write-Host "   Oracle DB: localhost:1521" -ForegroundColor Yellow
            Write-Host "   Redis: localhost:6379" -ForegroundColor Yellow
            Write-Host "   MinIO: http://localhost:9001" -ForegroundColor Yellow
            Write-Host "`n💡 To start the Next.js dev server:" -ForegroundColor Cyan
            Write-Host "   cd web && npm run dev" -ForegroundColor White
        } else {
            Write-Host "`n❌ Services failed to start. Check logs with:" -ForegroundColor Red
            Write-Host "   docker-compose logs" -ForegroundColor White
            exit 1
        }
        
        Set-Location "../.."
    }
    
    "staging" {
        Write-Host "`n📦 Deploying to staging..." -ForegroundColor Yellow
        
        # Check kubectl
        $kubectl = Get-Command kubectl -ErrorAction SilentlyContinue
        if (-not $kubectl) {
            Write-Host "❌ kubectl is not installed. Please install it first." -ForegroundColor Red
            exit 1
        }
        
        # Build and push image
        Write-Host "`n🔨 Building Docker image..." -ForegroundColor Yellow
        Set-Location "web"
        docker build -t ghcr.io/algodon/web:staging .
        docker push ghcr.io/algodon/web:staging
        Set-Location ".."
        
        # Deploy to Kubernetes
        Write-Host "`n🚀 Deploying to Kubernetes..." -ForegroundColor Yellow
        kubectl set image deployment/algodon-web web=ghcr.io/algodon/web:staging -n algodon
        kubectl rollout status deployment/algodon-web -n algodon
        
        Write-Host "`n✅ Staging deployment complete!" -ForegroundColor Green
        Write-Host "   URL: https://staging.algodon.app" -ForegroundColor Yellow
    }
    
    "production" {
        Write-Host "`n⚠️  PRODUCTION DEPLOYMENT" -ForegroundColor Red
        $confirm = Read-Host "Type 'DEPLOY' to confirm production deployment"
        
        if ($confirm -ne "DEPLOY") {
            Write-Host "Deployment cancelled." -ForegroundColor Yellow
            exit 0
        }
        
        # Check kubectl
        $kubectl = Get-Command kubectl -ErrorAction SilentlyContinue
        if (-not $kubectl) {
            Write-Host "❌ kubectl is not installed. Please install it first." -ForegroundColor Red
            exit 1
        }
        
        # Build and push image
        Write-Host "`n🔨 Building Docker image..." -ForegroundColor Yellow
        Set-Location "web"
        $tag = "ghcr.io/algodon/web:prod-$(Get-Date -Format 'yyyyMMdd-HHmmss')"
        docker build -t $tag .
        docker push $tag
        Set-Location ".."
        
        # Deploy to Kubernetes (canary)
        Write-Host "`n🚀 Deploying to production (canary 10%)..." -ForegroundColor Yellow
        kubectl set image deployment/algodon-web web=$tag -n algodon
        kubectl rollout status deployment/algodon-web -n algodon --timeout=5m
        
        # Smoke tests
        Write-Host "`n🧪 Running smoke tests..." -ForegroundColor Yellow
        Start-Sleep -Seconds 30
        try {
            $response = Invoke-WebRequest -Uri "https://algodon.app/api/health" -UseBasicParsing
            if ($response.StatusCode -eq 200) {
                Write-Host "✅ Smoke tests passed!" -ForegroundColor Green
                
                # Full rollout
                Write-Host "`n🚀 Scaling to 100%..." -ForegroundColor Yellow
                kubectl scale deployment/algodon-web --replicas=5 -n algodon
                kubectl rollout status deployment/algodon-web -n algodon
            }
        } catch {
            Write-Host "❌ Smoke tests failed! Rolling back..." -ForegroundColor Red
            kubectl rollout undo deployment/algodon-web -n algodon
            exit 1
        }
        
        Write-Host "`n✅ Production deployment complete!" -ForegroundColor Green
        Write-Host "   URL: https://algodon.app" -ForegroundColor Yellow
    }
}

Write-Host "`n✅ Deployment script complete!" -ForegroundColor Green
'@

$deployScript | Out-File -FilePath "deployment/scripts/deploy.ps1" -Encoding UTF8
Write-Host "✅ Created deployment script" -ForegroundColor Green

# Generate Terraform configuration
$terraformMain = @'
terraform {
  required_version = ">= 1.0"
  
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 5.0"
    }
  }
  
  backend "s3" {
    bucket = "algodon-terraform-state"
    key    = "terraform.tfstate"
    region = "us-east-1"
  }
}

provider "aws" {
  region = var.aws_region
}

# VPC
resource "aws_vpc" "main" {
  cidr_block           = "10.0.0.0/16"
  enable_dns_hostnames = true
  enable_dns_support   = true

  tags = {
    Name = "algodon-vpc"
  }
}

# Internet Gateway
resource "aws_internet_gateway" "main" {
  vpc_id = aws_vpc.main.id

  tags = {
    Name = "algodon-igw"
  }
}

# Public Subnets
resource "aws_subnet" "public" {
  count             = 2
  vpc_id            = aws_vpc.main.id
  cidr_block        = "10.0.${count.index + 1}.0/24"
  availability_zone = data.aws_availability_zones.available.names[count.index]

  map_public_ip_on_launch = true

  tags = {
    Name = "algodon-public-${count.index + 1}"
  }
}

# EKS Cluster
resource "aws_eks_cluster" "main" {
  name     = "algodon-cluster"
  role_arn = aws_iam_role.eks_cluster.arn
  version  = "1.28"

  vpc_config {
    subnet_ids = aws_subnet.public[*].id
  }

  depends_on = [
    aws_iam_role_policy_attachment.eks_cluster_policy,
  ]

  tags = {
    Name = "algodon-eks"
  }
}

# RDS Oracle Instance
resource "aws_db_instance" "oracle" {
  identifier     = "algodon-oracle"
  engine         = "oracle-se2"
  engine_version = "21.0.0.0"
  instance_class = "db.t3.medium"
  
  allocated_storage     = 100
  storage_type          = "gp3"
  storage_encrypted     = true
  
  db_name  = "XE"
  username = "algodon"
  password = var.db_password
  
  vpc_security_group_ids = [aws_security_group.rds.id]
  db_subnet_group_name   = aws_db_subnet_group.main.name
  
  backup_retention_period = 7
  backup_window          = "03:00-04:00"
  
  tags = {
    Name = "algodon-oracle"
  }
}

# ElastiCache Redis
resource "aws_elasticache_cluster" "redis" {
  cluster_id           = "algodon-redis"
  engine               = "redis"
  node_type            = "cache.t3.micro"
  num_cache_nodes      = 1
  parameter_group_name = "default.redis7"
  port                 = 6379
  
  subnet_group_name    = aws_elasticache_subnet_group.main.name
  security_group_ids    = [aws_security_group.redis.id]
  
  tags = {
    Name = "algodon-redis"
  }
}

# S3 Bucket for storage
resource "aws_s3_bucket" "storage" {
  bucket = "algodon-storage-${random_id.bucket_suffix.hex}"

  tags = {
    Name = "algodon-storage"
  }
}

resource "aws_s3_bucket_versioning" "storage" {
  bucket = aws_s3_bucket.storage.id
  versioning_configuration {
    status = "Enabled"
  }
}

# CloudFront Distribution
resource "aws_cloudfront_distribution" "cdn" {
  origin {
    domain_name = aws_s3_bucket.storage.bucket_regional_domain_name
    origin_id   = "S3-${aws_s3_bucket.storage.id}"

    s3_origin_config {
      origin_access_identity = aws_cloudfront_origin_access_identity.main.cloudfront_access_identity_path
    }
  }

  enabled             = true
  is_ipv6_enabled     = true
  default_root_object = "index.html"

  default_cache_behavior {
    allowed_methods  = ["DELETE", "GET", "HEAD", "OPTIONS", "PATCH", "POST", "PUT"]
    cached_methods   = ["GET", "HEAD"]
    target_origin_id = "S3-${aws_s3_bucket.storage.id}"

    forwarded_values {
      query_string = false
      cookies {
        forward = "none"
      }
    }

    viewer_protocol_policy = "redirect-to-https"
    min_ttl                = 0
    default_ttl            = 3600
    max_ttl                = 86400
  }

  restrictions {
    geo_restriction {
      restriction_type = "none"
    }
  }

  viewer_certificate {
    cloudfront_default_certificate = true
  }

  tags = {
    Name = "algodon-cdn"
  }
}

variable "aws_region" {
  description = "AWS region"
  default     = "us-east-1"
}

variable "db_password" {
  description = "Oracle database password"
  type        = string
  sensitive   = true
}

data "aws_availability_zones" "available" {
  state = "available"
}

resource "random_id" "bucket_suffix" {
  byte_length = 4
}
'@

$terraformMain | Out-File -FilePath "deployment/terraform/main.tf" -Encoding UTF8
Write-Host "✅ Created Terraform configuration" -ForegroundColor Green

# Generate README for deployment
$deploymentReadme = @'
# ALGODON Deployment Guide

## Quick Start

### Local Development

```powershell
.\deployment\scripts\deploy.ps1 local
```

This will:
- Start Docker Compose with all services (Oracle, Redis, PostgreSQL, MinIO)
- Wait for services to be healthy
- Provide URLs for accessing services

Then start the Next.js dev server:
```bash
cd web
npm install
npm run dev
```

### Staging Deployment

```powershell
.\deployment\scripts\deploy.ps1 staging
```

### Production Deployment

```powershell
.\deployment\scripts\deploy.ps1 production
```

## Prerequisites

- Docker Desktop
- Node.js 20+
- kubectl (for staging/production)
- AWS CLI (for Terraform)

## Environment Variables

Copy `web/.env.example` to `web/.env` and fill in:
- Database connection strings
- API keys (Stripe, OpenAI, etc.)
- AWS credentials

## Database Setup

1. Run Oracle schema migration:
```sql
@database/oracle/schemas/01_schema.sql
```

2. Seed initial data:
```sql
@database/oracle/seeds/01_seed.sql
```

## Monitoring

- Health check: `http://localhost:3000/api/health`
- Prometheus: `http://localhost:9090`
- Grafana: `http://localhost:3001`

## Troubleshooting

### Services not starting
```bash
docker-compose logs
```

### Database connection issues
```bash
docker-compose exec oracle-db sqlplus algodon/password@localhost:1521/XE
```

### Reset everything
```bash
docker-compose down -v
docker-compose up -d
```
'@

$deploymentReadme | Out-File -FilePath "deployment/README.md" -Encoding UTF8
Write-Host "✅ Created deployment README" -ForegroundColor Green

Write-Host "`n✅ Part 6: Deployment & CI/CD Complete!" -ForegroundColor Green
Write-Host "`n🎉 All 6 parts complete! ALGODON is ready to deploy!" -ForegroundColor Cyan
Write-Host "`nNext steps:" -ForegroundColor Yellow
Write-Host "1. Run all PowerShell scripts in order (part1 through part6)" -ForegroundColor White
Write-Host "2. Install dependencies: cd web && npm install" -ForegroundColor White
Write-Host "3. Set up environment variables: cp web/.env.example web/.env" -ForegroundColor White
Write-Host "4. Start local environment: .\deployment\scripts\deploy.ps1 local" -ForegroundColor White
Write-Host "5. Start dev server: cd web && npm run dev" -ForegroundColor White