@maestro-ai/mcp-server 1.2.0 → 2.0.0

package/dist/content/skills/specialist-devops-infra/mcp_functions/generate_ci_cd_pipeline.py

@@ -0,0 +1,870 @@
+#!/usr/bin/env python3
+"""
+Função MCP de Referência: generate_ci_cd_pipeline
+
+Esta função serve como referência para implementação no MCP.
+NÃO EXECUTÁVEL LOCALMENTE - Apenas documentação da estrutura esperada.
+
+Propósito: Gerar pipeline de CI/CD completo
+"""
+
+async def generate_ci_cd_pipeline(params: dict) -> dict:
+    """
+    Gera pipeline de CI/CD completo
+    
+    Args:
+        params: {
+            "provider": str,                      # github_actions|gitlab_ci
+            "stack": dict,                        # Stack tecnológica
+            "environments": list[str],             # Ambientes configurados
+            "deployment_target": str,             # ecs|kubernetes|vm|serverless
+            "security_requirements": dict,        # Requisitos de segurança
+            "performance_requirements": dict,      # Requisitos de performance
+            "compliance_requirements": dict       # Requisitos de compliance
+        }
+    
+    Returns:
+        dict: {
+            "success": bool,                      # Status da geração
+            "pipeline_path": str,                 # Caminho do arquivo gerado
+            "pipeline_content": str,              # Conteúdo do pipeline
+            "deployment_steps": list[str],        # Passos de deploy
+            "validation_required": bool,          # Requer validação manual
+            "security_integrations": list[str],   # Integrações de segurança
+            "monitoring_setup": dict,             # Configuração de monitoring
+            "next_actions": list[str]             # Próximas ações
+        }
+    """
+    
+    # IMPLEMENTAÇÃO ESPERADA NO MCP:
+    
+    provider = params["provider"]
+    stack = params["stack"]
+    environments = params["environments"]
+    deployment_target = params.get("deployment_target", "ecs")
+    
+    # 1. Gerar conteúdo base do pipeline
+    pipeline_content = await generate_pipeline_base(provider, stack, environments)
+    
+    # 2. Adicionar stages de build e test
+    pipeline_content = await add_build_test_stages(pipeline_content, provider, stack)
+    
+    # 3. Adicionar security scanning
+    pipeline_content = await add_security_stages(pipeline_content, provider, params.get("security_requirements", {}))
+    
+    # 4. Adicionar deploy stages
+    pipeline_content = await add_deploy_stages(pipeline_content, provider, environments, deployment_target)
+    
+    # 5. Adicionar monitoring e alerting
+    pipeline_content = await add_monitoring_stages(pipeline_content, provider, params.get("performance_requirements", {}))
+    
+    # 6. Adicionar compliance checks
+    pipeline_content = await add_compliance_stages(pipeline_content, provider, params.get("compliance_requirements", {}))
+    
+    # 7. Gerar arquivo do pipeline
+    pipeline_path = await create_pipeline_file(provider, pipeline_content)
+    
+    # 8. Gerar deployment steps
+    deployment_steps = generate_deployment_steps(environments, deployment_target)
+    
+    # 9. Identificar security integrations
+    security_integrations = identify_security_integrations(pipeline_content)
+    
+    # 10. Configurar monitoring setup
+    monitoring_setup = configure_monitoring_setup(provider, stack)
+    
+    # 11. Gerar próximas ações
+    next_actions = generate_next_actions(provider, pipeline_path, environments)
+    
+    return {
+        "success": True,
+        "pipeline_path": pipeline_path,
+        "pipeline_content": pipeline_content,
+        "deployment_steps": deployment_steps,
+        "validation_required": determine_validation_requirement(environments),
+        "security_integrations": security_integrations,
+        "monitoring_setup": monitoring_setup,
+        "next_actions": next_actions
+    }
+
+
+# FUNÇÕES DE GERAÇÃO
+
+async def generate_pipeline_base(provider: str, stack: dict, environments: list[str]) -> str:
+    """
+    Gera estrutura base do pipeline
+    
+    Args:
+        provider: Provider do CI/CD
+        stack: Stack tecnológica
+        environments: Lista de ambientes
+        
+    Returns:
+        str: Conteúdo base do pipeline
+    """
+    if provider == "github_actions":
+        return generate_github_actions_base(stack, environments)
+    elif provider == "gitlab_ci":
+        return generate_gitlab_ci_base(stack, environments)
+    else:
+        raise ValueError(f"Provider não suportado: {provider}")
+
+
+def generate_github_actions_base(stack: dict, environments: list[str]) -> str:
+    """
+    Gera base do GitHub Actions
+    
+    Args:
+        stack: Stack tecnológica
+        environments: Lista de ambientes
+        
+    Returns:
+        str: Base do GitHub Actions
+    """
+    language = stack.get("language", "NODE")
+    
+    return f"""name: CI/CD Pipeline
+
+on:
+  push:
+    branches: {json.dumps(["main", "develop"])}
+  pull_request:
+    branches: ["main"]
+
+env:
+  {get_environment_variables(language)}
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup {language}
+        uses: {get_setup_action(language)}
+        with:
+          {get_setup_config(language)}
+      - name: Install dependencies
+        run: {get_install_command(language)}
+      - name: Run linting
+        run: {get_lint_command(language)}
+
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: {get_test_matrix(language)}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup {language}
+        uses: {get_setup_action(language)}
+        with:
+          {get_setup_config(language)}
+      - name: Install dependencies
+        run: {get_install_command(language)}
+      - name: Run tests
+        run: {get_test_command(language)}
+      - name: Generate coverage report
+        run: {get_coverage_command(language)}
+      - name: Upload coverage
+        uses: codecov/codecov-action@v3
+        with:
+          file: {get_coverage_file(language)}
+
+  security:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Run SAST
+        uses: {get_sast_action(language)}
+      - name: Run SCA
+        uses: {get_sca_action(language)}
+        with:
+          token: ${{{{ secrets.SNYK_TOKEN }}}}
+      - name: Container Security Scan
+        uses: aquasecurity/trivy-action@master
+
+  build:
+    needs: [lint, test, security]
+    runs-on: ubuntu-latest
+    outputs:
+      image-tag: ${{{{ steps.meta.outputs.tags }}}}
+      image-digest: ${{{{ steps.build.outputs.digest }}}}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Login to Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{{{ secrets.CONTAINER_REGISTRY }}}}
+          username: ${{{{ secrets.CONTAINER_USERNAME }}}}
+          password: ${{{{ secrets.CONTAINER_PASSWORD }}}}
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{{{ secrets.CONTAINER_REGISTRY }}}}/{get_image_name(stack)}
+          tags: |
+            type=ref,event=branch
+            type=ref,event=pr
+            type=sha,prefix={{branch}}-
+            type=raw,value=latest,enable={{{{is_default_branch}}}}
+      - name: Build and push Docker image
+        id: build
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          tags: ${{{{ steps.meta.outputs.tags }}}}
+          labels: ${{{{ steps.meta.outputs.labels }}}}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+          platforms: linux/amd64,linux/arm64
+"""
+
+
+def generate_gitlab_ci_base(stack: dict, environments: list[str]) -> str:
+    """
+    Gera base do GitLab CI
+    
+    Args:
+        stack: Stack tecnológica
+        environments: Lista de ambientes
+        
+    Returns:
+        str: Base do GitLab CI
+    """
+    language = stack.get("language", "NODE")
+    
+    return f"""stages:
+  - lint
+  - test
+  - security
+  - build
+  - deploy
+
+variables:
+  {get_gitlab_variables(language)}
+  DOCKER_DRIVER: overlay2
+  DOCKER_TLS_CERTDIR: "/certs"
+
+lint:
+  stage: lint
+  image: {get_gitlab_image(language)}
+  cache:
+    paths:
+      - {get_cache_path(language)}
+  script:
+    - {get_gitlab_install_command(language)}
+    - {get_lint_command(language)}
+
+test:
+  stage: test
+  image: {get_gitlab_image(language)}
+  cache:
+    paths:
+      - {get_cache_path(language)}
+  script:
+    - {get_gitlab_install_command(language)}
+    - {get_test_command(language)}
+    - {get_coverage_command(language)}
+  coverage: '/{get_coverage_regex(language)}/'
+  artifacts:
+    reports:
+      coverage_report:
+        coverage_format: cobertura
+        path: {get_coverage_file(language)}
+
+security:
+  stage: security
+  image: {get_gitlab_image(language)}
+  script:
+    - {get_gitlab_install_command(language)}
+    - npm audit --audit-level moderate
+    - {get_security_scan_command(language)}
+
+build:
+  stage: build
+  image: docker:20.10.16
+  services:
+    - docker:20.10.16-dind
+  script:
+    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
+    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
+  only:
+    - main
+    - develop
+"""
+
+
+async def add_build_test_stages(pipeline_content: str, provider: str, stack: dict) -> str:
+    """
+    Adiciona stages de build e test ao pipeline
+    
+    Args:
+        pipeline_content: Conteúdo atual do pipeline
+        provider: Provider do CI/CD
+        stack: Stack tecnológica
+        
+    Returns:
+        str: Pipeline com stages de build/test
+    """
+    language = stack.get("language", "NODE")
+    
+    if provider == "github_actions":
+        # GitHub Actions já inclui stages de build/test no base
+        return pipeline_content
+    elif provider == "gitlab_ci":
+        # GitLab CI já inclui stages de build/test no base
+        return pipeline_content
+    
+    return pipeline_content
+
+
+async def add_security_stages(pipeline_content: str, provider: str, security_requirements: dict) -> str:
+    """
+    Adiciona stages de segurança ao pipeline
+    
+    Args:
+        pipeline_content: Conteúdo atual do pipeline
+        provider: Provider do CI/CD
+        security_requirements: Requisitos de segurança
+        
+    Returns:
+        str: Pipeline com stages de segurança
+    """
+    if not security_requirements:
+        return pipeline_content
+    
+    # Adicionar stages específicos baseado nos requisitos
+    if security_requirements.get("sast_required", True):
+        pipeline_content = add_sast_stage(pipeline_content, provider)
+    
+    if security_requirements.get("sca_required", True):
+        pipeline_content = add_sca_stage(pipeline_content, provider)
+    
+    if security_requirements.get("container_scan_required", True):
+        pipeline_content = add_container_scan_stage(pipeline_content, provider)
+    
+    return pipeline_content
+
+
+async def add_deploy_stages(pipeline_content: str, provider: str, environments: list[str], deployment_target: str) -> str:
+    """
+    Adiciona stages de deploy ao pipeline
+    
+    Args:
+        pipeline_content: Conteúdo atual do pipeline
+        provider: Provider do CI/CD
+        environments: Lista de ambientes
+        deployment_target: Alvo do deploy
+        
+    Returns:
+        str: Pipeline com stages de deploy
+    """
+    if provider == "github_actions":
+        return add_github_deploy_stages(pipeline_content, environments, deployment_target)
+    elif provider == "gitlab_ci":
+        return add_gitlab_deploy_stages(pipeline_content, environments, deployment_target)
+    
+    return pipeline_content
+
+
+def add_github_deploy_stages(pipeline_content: str, environments: list[str], deployment_target: str) -> str:
+    """
+    Adiciona stages de deploy no GitHub Actions
+    
+    Args:
+        pipeline_content: Conteúdo atual do pipeline
+        environments: Lista de ambientes
+        deployment_target: Alvo do deploy
+        
+    Returns:
+        str: Pipeline com stages de deploy
+    """
+    deploy_stages = ""
+    
+    for env in environments:
+        if env == "dev":
+            deploy_stages += f"""
+  deploy-dev:
+    needs: build
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/develop'
+    environment: development
+    steps:
+      - name: Deploy to {deployment_target}
+        run: |
+          {get_deploy_command(deployment_target, env)}
+"""
+        elif env == "staging":
+            deploy_stages += f"""
+  deploy-staging:
+    needs: build
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main'
+    environment: staging
+    steps:
+      - name: Deploy to {deployment_target}
+        run: |
+          {get_deploy_command(deployment_target, env)}
+"""
+        elif env == "prod":
+            deploy_stages += f"""
+  deploy-prod:
+    needs: deploy-staging
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main'
+    environment: production
+    steps:
+      - name: Deploy to {deployment_target}
+        run: |
+          {get_deploy_command(deployment_target, env)}
+"""
+    
+    return pipeline_content + deploy_stages
+
+
+def add_gitlab_deploy_stages(pipeline_content: str, environments: list[str], deployment_target: str) -> str:
+    """
+    Adiciona stages de deploy no GitLab CI
+    
+    Args:
+        pipeline_content: Conteúdo atual do pipeline
+        environments: Lista de ambientes
+        deployment_target: Alvo do deploy
+        
+    Returns:
+        str: Pipeline com stages de deploy
+    """
+    deploy_stages = ""
+    
+    for env in environments:
+        deploy_stages += f"""
+deploy-{env}:
+  stage: deploy
+  image: alpine:latest
+  script:
+    - echo "Deploy to {env} environment"
+    - {get_deploy_command(deployment_target, env)}
+  environment:
+    name: {env}
+    url: https://{env}.example.com
+  only:
+    - main
+"""
+    
+    return pipeline_content + deploy_stages
+
+
+async def add_monitoring_stages(pipeline_content: str, provider: str, performance_requirements: dict) -> str:
+    """
+    Adiciona stages de monitoring ao pipeline
+    
+    Args:
+        pipeline_content: Conteúdo atual do pipeline
+        provider: Provider do CI/CD
+        performance_requirements: Requisitos de performance
+        
+    Returns:
+        str: Pipeline com stages de monitoring
+    """
+    if not performance_requirements:
+        return pipeline_content
+    
+    # Adicionar stage de performance testing
+    if performance_requirements.get("load_testing_required", False):
+        pipeline_content = add_load_testing_stage(pipeline_content, provider)
+    
+    # Adicionar stage de health check
+    pipeline_content = add_health_check_stage(pipeline_content, provider)
+    
+    return pipeline_content
+
+
+async def add_compliance_stages(pipeline_content: str, provider: str, compliance_requirements: dict) -> str:
+    """
+    Adiciona stages de compliance ao pipeline
+    
+    Args:
+        pipeline_content: Conteúdo atual do pipeline
+        provider: Provider do CI/CD
+        compliance_requirements: Requisitos de compliance
+        
+    Returns:
+        str: Pipeline com stages de compliance
+    """
+    if not compliance_requirements:
+        return pipeline_content
+    
+    # Adicionar stage de compliance check
+    compliance_stage = f"""
+  compliance-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Run Compliance Checks
+        run: |
+          echo "Running compliance checks..."
+          {get_compliance_checks(compliance_requirements)}
+"""
+    
+    if provider == "github_actions":
+        return pipeline_content + compliance_stage
+    
+    return pipeline_content
+
+
+# FUNÇÕES AUXILIARES
+
+def get_environment_variables(language: str) -> str:
+    """Retorna variáveis de ambiente por linguagem"""
+    return {
+        "NODE": "NODE_VERSION: '20'",
+        "PYTHON": "PYTHON_VERSION: '3.11'",
+        "JAVA": "JAVA_VERSION: '17'",
+        "GO": "GO_VERSION: '1.21'"
+    }.get(language, "NODE_VERSION: '20'")
+
+
+def get_setup_action(language: str) -> str:
+    """Retorna action de setup por linguagem"""
+    return {
+        "NODE": "actions/setup-node@v4",
+        "PYTHON": "actions/setup-python@v4",
+        "JAVA": "actions/setup-java@v4",
+        "GO": "actions/setup-go@v4"
+    }.get(language, "actions/setup-node@v4")
+
+
+def get_setup_config(language: str) -> str:
+    """Retorna configuração de setup por linguagem"""
+    configs = {
+        "NODE": "node-version: ${{ env.NODE_VERSION }}\n          cache: 'npm'",
+        "PYTHON": "python-version: ${{ env.PYTHON_VERSION }}\n          cache: 'pip'",
+        "JAVA": "java-version: ${{ env.JAVA_VERSION }}\n          distribution: 'temurin'",
+        "GO": "go-version: ${{ env.GO_VERSION }}\n          cache: true"
+    }
+    return configs.get(language, "node-version: ${{ env.NODE_VERSION }}\n          cache: 'npm'")
+
+
+def get_install_command(language: str) -> str:
+    """Retorna comando de install por linguagem"""
+    return {
+        "NODE": "npm ci",
+        "PYTHON": "pip install -r requirements.txt",
+        "JAVA": "mvn dependency:resolve",
+        "GO": "go mod download"
+    }.get(language, "npm ci")
+
+
+def get_lint_command(language: str) -> str:
+    """Retorna comando de lint por linguagem"""
+    return {
+        "NODE": "npm run lint",
+        "PYTHON": "flake8 .",
+        "JAVA": "mvn checkstyle:check",
+        "GO": "golangci-lint run"
+    }.get(language, "npm run lint")
+
+
+def get_test_command(language: str) -> str:
+    """Retorna comando de test por linguagem"""
+    return {
+        "NODE": "npm test",
+        "PYTHON": "pytest",
+        "JAVA": "mvn test",
+        "GO": "go test ./..."
+    }.get(language, "npm test")
+
+
+def get_coverage_command(language: str) -> str:
+    """Retorna comando de coverage por linguagem"""
+    return {
+        "NODE": "npm run test:coverage",
+        "PYTHON": "pytest --cov=. --cov-report=xml",
+        "JAVA": "mvn jacoco:report",
+        "GO": "go test -coverprofile=coverage.out ./..."
+    }.get(language, "npm run test:coverage")
+
+
+def get_coverage_file(language: str) -> str:
+    """Retorna arquivo de coverage por linguagem"""
+    return {
+        "NODE": "coverage/lcov.info",
+        "PYTHON": "coverage.xml",
+        "JAVA": "target/site/jacoco/jacoco.xml",
+        "GO": "coverage.out"
+    }.get(language, "coverage/lcov.info")
+
+
+def get_test_matrix(language: str) -> str:
+    """Retorna matrix de test por linguagem"""
+    return {
+        "NODE": "[18, 20]",
+        "PYTHON": "[3.10, 3.11]",
+        "JAVA": "[17, 21]",
+        "GO": "[1.20, 1.21]"
+    }.get(language, "[18, 20]")
+
+
+def get_sast_action(language: str) -> str:
+    """Retorna action de SAST por linguagem"""
+    return {
+        "NODE": "securecodewarrior/github-action-add-sarif@v1",
+        "PYTHON": "securecodewarrior/github-action-add-sarif@v1",
+        "JAVA": "securecodewarrior/github-action-add-sarif@v1",
+        "GO": "securecodewarrior/github-action-add-sarif@v1"
+    }.get(language, "securecodewarrior/github-action-add-sarif@v1")
+
+
+def get_sca_action(language: str) -> str:
+    """Retorna action de SCA por linguagem"""
+    return {
+        "NODE": "snyk/actions/node@master",
+        "PYTHON": "snyk/actions/python@master",
+        "JAVA": "snyk/actions/maven@master",
+        "GO": "snyk/actions/go@master"
+    }.get(language, "snyk/actions/node@master")
+
+
+def get_image_name(stack: dict) -> str:
+    """Retorna nome da imagem baseado na stack"""
+    language = stack.get("language", "app").lower()
+    framework = stack.get("framework", "").lower()
+    
+    if framework:
+        return f"{language}-{framework}"
+    return language
+
+
+def get_deploy_command(deployment_target: str, environment: str) -> str:
+    """Retorna comando de deploy por target"""
+    commands = {
+        "ecs": f"aws ecs update-service --cluster {environment}-cluster --service app-service --force-new-deployment",
+        "kubernetes": f"kubectl apply -f k8s/{environment}/ && kubectl rollout status deployment/app -n {environment}",
+        "vm": f"ansible-playbook deploy.yml -i inventory/{environment}",
+        "serverless": f"serverless deploy --stage {environment}"
+    }
+    
+    return commands.get(deployment_target, f"echo 'Deploy to {environment}'")
+
+
+def get_compliance_checks(compliance_requirements: dict) -> str:
+    """Retorna comandos de compliance"""
+    checks = []
+    
+    if compliance_requirements.get("pci_dss", False):
+        checks.append("run-pci-scan.sh")
+    
+    if compliance_requirements.get("gdpr", False):
+        checks.append("run-gdpr-check.sh")
+    
+    if compliance_requirements.get("soc2", False):
+        checks.append("run-soc2-audit.sh")
+    
+    return "\n          ".join(checks) if checks else "echo 'No compliance checks required'"
+
+
+# FUNÇÕES DE PÓS-PROCESSAMENTO
+
+async def create_pipeline_file(provider: str, pipeline_content: str) -> str:
+    """
+    Cria arquivo do pipeline
+    
+    Args:
+        provider: Provider do CI/CD
+        pipeline_content: Conteúdo do pipeline
+        
+    Returns:
+        str: Caminho do arquivo criado
+    """
+    if provider == "github_actions":
+        path = ".github/workflows/ci-cd.yml"
+    elif provider == "gitlab_ci":
+        path = ".gitlab-ci.yml"
+    else:
+        path = "pipeline.yml"
+    
+    # Implementação MCP: Escrever arquivo
+    await write_file(path, pipeline_content)
+    
+    return path
+
+
+def generate_deployment_steps(environments: list[str], deployment_target: str) -> list[str]:
+    """
+    Gera lista de passos de deploy
+    
+    Args:
+        environments: Lista de ambientes
+        deployment_target: Alvo do deploy
+        
+    Returns:
+        list[str]: Passos de deploy
+    """
+    steps = []
+    
+    for env in environments:
+        steps.extend([
+            f"1. Configure {deployment_target} for {env}",
+            f"2. Set up environment variables for {env}",
+            f"3. Deploy application to {env}",
+            f"4. Run health checks on {env}",
+            f"5. Verify {env} deployment"
+        ])
+    
+    return steps
+
+
+def identify_security_integrations(pipeline_content: str) -> list[str]:
+    """
+    Identifica integrações de segurança no pipeline
+    
+    Args:
+        pipeline_content: Conteúdo do pipeline
+        
+    Returns:
+        list[str]: Lista de integrações
+    """
+    integrations = []
+    
+    if "SAST" in pipeline_content:
+        integrations.append("Static Application Security Testing (SAST)")
+    
+    if "SCA" in pipeline_content:
+        integrations.append("Software Composition Analysis (SCA)")
+    
+    if "trivy" in pipeline_content:
+        integrations.append("Container Security Scanning")
+    
+    if "snyk" in pipeline_content:
+        integrations.append("Snyk Security Platform")
+    
+    return integrations
+
+
+def configure_monitoring_setup(provider: str, stack: dict) -> dict:
+    """
+    Configura setup de monitoring
+    
+    Args:
+        provider: Provider do CI/CD
+        stack: Stack tecnológica
+        
+    Returns:
+        dict: Configuração de monitoring
+    """
+    return {
+        "metrics": {
+            "enabled": True,
+            "tool": "Prometheus",
+            "endpoints": ["/metrics", "/health"]
+        },
+        "logging": {
+            "enabled": True,
+            "tool": "ELK Stack",
+            "format": "JSON"
+        },
+        "tracing": {
+            "enabled": True,
+            "tool": "Jaeger",
+            "sampling_rate": "0.1"
+        },
+        "alerting": {
+            "enabled": True,
+            "tool": "Grafana",
+            "channels": ["slack", "email"]
+        }
+    }
+
+
+def generate_next_actions(provider: str, pipeline_path: str, environments: list[str]) -> list[str]:
+    """
+    Gera próximas ações
+    
+    Args:
+        provider: Provider do CI/CD
+        pipeline_path: Caminho do pipeline
+        environments: Lista de ambientes
+        
+    Returns:
+        list[str]: Próximas ações
+    """
+    actions = [
+        f"1. Review {provider} pipeline at {pipeline_path}",
+        "2. Configure required secrets and variables",
+        "3. Test pipeline with dry run",
+        "4. Validate deployment to development environment"
+    ]
+    
+    if "staging" in environments:
+        actions.append("5. Validate deployment to staging environment")
+    
+    if "prod" in environments:
+        actions.extend([
+            "6. Configure production deployment approvals",
+            "7. Validate production deployment process"
+        ])
+    
+    actions.extend([
+        "8. Set up monitoring and alerting",
+        "9. Configure backup and disaster recovery",
+        "10. Document runbooks and procedures"
+    ])
+    
+    return actions
+
+
+def determine_validation_requirement(environments: list[str]) -> bool:
+    """
+    Determina se validação manual é requerida
+    
+    Args:
+        environments: Lista de ambientes
+        
+    Returns:
+        bool: Requer validação manual
+    """
+    return "prod" in environments
+
+
+# EXEMPLO DE USO
+
+if __name__ == "__main__":
+    """
+    Exemplo de como a função seria chamada no MCP:
+    
+    result = await generate_ci_cd_pipeline({
+        "provider": "github_actions",
+        "stack": {
+            "language": "NODE",
+            "framework": "NEST",
+            "database": "POSTGRES",
+            "cloud_provider": "AWS"
+        },
+        "environments": ["dev", "staging", "prod"],
+        "deployment_target": "ecs",
+        "security_requirements": {
+            "sast_required": True,
+            "sca_required": True,
+            "container_scan_required": True
+        },
+        "performance_requirements": {
+            "load_testing_required": True
+        },
+        "compliance_requirements": {
+            "pci_dss": True,
+            "soc2": True
+        }
+    })
+    
+    print(f"Pipeline Generated: {result['success']}")
+    print(f"Pipeline Path: {result['pipeline_path']}")
+    print(f"Security Integrations: {len(result['security_integrations'])}")
+    print(f"Deployment Steps: {len(result['deployment_steps'])}")
+    """
+    
+    print("Esta é uma função de referência para implementação no MCP.")
+    print("NÃO EXECUTÁVEL LOCALMENTE.")
+    print("Consulte MCP_INTEGRATION.md para detalhes de implementação.")