@maestro-ai/mcp-server 1.1.0 → 2.0.0

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

@@ -0,0 +1,704 @@
+#!/usr/bin/env python3
+"""
+Função MCP de Referência: init_infrastructure_structure
+
+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: Criar estrutura base da infraestrutura com template padrão
+"""
+
+async def init_infrastructure_structure(params: dict) -> dict:
+    """
+    Inicializa estrutura base da infraestrutura
+    
+    Args:
+        params: {
+            "project_name": str,                    # Nome do projeto
+            "stack": {
+                "language": str,                    # NODE|PYTHON|JAVA|GO|RUST
+                "framework": str,                   # NEXT|NEST|DJANGO|FASTAPI|SPRING
+                "database": str,                    # POSTGRES|MYSQL|MONGO|REDIS
+                "cloud_provider": str               # AWS|GCP|AZURE
+            },
+            "environments": list[str],               # ["dev", "staging", "prod"]
+            "compliance_requirements": dict,        # Requisitos de compliance
+            "team_contact": str                     # Email/time responsável
+        }
+    
+    Returns:
+        dict: {
+            "success": bool,                        # Status da operação
+            "structure": dict,                      # Estrutura JSON preenchida
+            "template_path": str,                   # Caminho do template usado
+            "created_files": list[str],             # Arquivos criados
+            "next_steps": list[str],                # Próximos passos recomendados
+            "validation_score": int,                # Score inicial de validação
+            "errors": list[dict]                    # Erros encontrados
+        }
+    """
+    
+    # IMPLEMENTAÇÃO ESPERADA NO MCP:
+    
+    # 1. Carregar template base
+    template_content = await load_template("estado-template.json")
+    
+    # 2. Preencher informações do projeto
+    template_content["infraestrutura"]["stack"] = params["stack"]
+    template_content["infraestrutura"]["cloud_provider"] = params["stack"]["cloud_provider"]
+    
+    # 3. Configurar ambientes
+    for env in params["environments"]:
+        template_content["infraestrutura"]["ambientes"][env] = {
+            "url": f"{env}-{params['project_name'].lower().replace(' ', '-')}.example.com",
+            "status": "pending",
+            "last_deploy": None
+        }
+    
+    # 4. Configurar CI/CD base
+    template_content["infraestrutura"]["ci_cd"] = {
+        "provider": "GITHUB_ACTIONS",  # Default
+        "status": "not_configured",
+        "pipeline_url": ""
+    }
+    
+    # 5. Configurar container registry base
+    template_content["infraestrutura"]["container"] = {
+        "registry": get_registry_for_provider(params["stack"]["cloud_provider"]),
+        "image_name": params["project_name"].lower().replace(' ', '-'),
+        "latest_tag": "v1.0.0"
+    }
+    
+    # 6. Configurar IaC base
+    template_content["infraestrutura"]["iac"] = {
+        "tool": "TERRAFORM",  # Default
+        "state_location": get_state_location(params["stack"]["cloud_provider"], params["project_name"]),
+        "coverage": 0
+    }
+    
+    # 7. Configurar compliance base
+    compliance = params.get("compliance_requirements", {})
+    template_content["compliance"] = {
+        "security_scan": compliance.get("security_scan", False),
+        "secrets_management": compliance.get("secrets_management", False),
+        "backup_configured": compliance.get("backup_configured", False),
+        "monitoring_enabled": compliance.get("monitoring_enabled", False)
+    }
+    
+    # 8. Adicionar histórico inicial
+    template_content["history"] = [{
+        "timestamp": datetime.now().isoformat(),
+        "action": "infrastructure_initialized",
+        "version": "v1.0.0",
+        "author": params.get("team_contact", "devops-team"),
+        "details": f"Infrastructure initialized for {params['project_name']}"
+    }]
+    
+    # 9. Criar estrutura de diretórios
+    created_files = await create_directory_structure(params["project_name"])
+    
+    # 10. Gerar arquivos base
+    base_files = await generate_base_files(template_content, params)
+    created_files.extend(base_files)
+    
+    # 11. Calcular score inicial
+    validation_score = calculate_initial_score(template_content)
+    
+    # 12. Gerar próximos passos
+    next_steps = generate_next_steps(template_content, validation_score)
+    
+    return {
+        "success": True,
+        "structure": template_content,
+        "template_path": "resources/templates/estado-template.json",
+        "created_files": created_files,
+        "next_steps": next_steps,
+        "validation_score": validation_score,
+        "errors": []
+    }
+
+
+# FUNÇÕES AUXILIARES (Referência)
+
+async def load_template(template_name: str) -> dict:
+    """
+    Carrega template JSON do arquivo
+    
+    Args:
+        template_name: Nome do arquivo template
+        
+    Returns:
+        dict: Conteúdo do template
+    """
+    # Implementação MCP: Ler arquivo de template
+    template_path = f"resources/templates/{template_name}"
+    
+    # Exemplo de implementação:
+    with open(template_path, 'r') as f:
+        return json.load(f)
+
+
+def get_registry_for_provider(cloud_provider: str) -> str:
+    """
+    Retorna registry padrão baseado no cloud provider
+    
+    Args:
+        cloud_provider: AWS|GCP|AZURE
+        
+    Returns:
+        str: URL do registry
+    """
+    registries = {
+        "AWS": "123456789012.dkr.ecr.us-east-1.amazonaws.com",
+        "GCP": "gcr.io/meu-projeto-12345",
+        "AZURE": "myregistry.azurecr.io"
+    }
+    
+    return registries.get(cloud_provider, "")
+
+
+def get_state_location(cloud_provider: str, project_name: str) -> str:
+    """
+    Retorna localização do state do Terraform
+    
+    Args:
+        cloud_provider: AWS|GCP|AZURE
+        project_name: Nome do projeto
+        
+    Returns:
+        str: Localização do state
+    """
+    locations = {
+        "AWS": f"s3://{project_name.lower().replace(' ', '-')}-terraform-state",
+        "GCP": f"gs://{project_name.lower().replace(' ', '-')}-terraform-state",
+        "AZURE": f"{project_name.lower().replace(' ', '-')}storage.blob.core.windows.net/terraform-state"
+    }
+    
+    return locations.get(cloud_provider, "")
+
+
+async def create_directory_structure(project_name: str) -> list[str]:
+    """
+    Cria estrutura de diretórios para o projeto
+    
+    Args:
+        project_name: Nome do projeto
+        
+    Returns:
+        list[str]: Diretórios criados
+    """
+    base_name = project_name.lower().replace(' ', '-')
+    
+    directories = [
+        f"infra/{base_name}/",
+        f"infra/{base_name}/environments/",
+        f"infra/{base_name}/modules/",
+        f".github/workflows/",
+        f"docker/",
+        f"monitoring/",
+        f"docs/infrastructure/"
+    ]
+    
+    # Implementação MCP: Criar diretórios
+    created_dirs = []
+    for directory in directories:
+        try:
+            os.makedirs(directory, exist_ok=True)
+            created_dirs.append(directory)
+        except Exception as e:
+            logger.error(f"Failed to create directory {directory}: {e}")
+    
+    return created_dirs
+
+
+async def generate_base_files(template_content: dict, params: dict) -> list[str]:
+    """
+    Gera arquivos base para a infraestrutura
+    
+    Args:
+        template_content: Template preenchido
+        params: Parâmetros do projeto
+        
+    Returns:
+        list[str]: Arquivos criados
+    """
+    project_name = params["project_name"].lower().replace(' ', '-')
+    stack = params["stack"]
+    
+    created_files = []
+    
+    # 1. Dockerfile
+    dockerfile_content = generate_dockerfile(stack)
+    dockerfile_path = f"Dockerfile"
+    await write_file(dockerfile_path, dockerfile_content)
+    created_files.append(dockerfile_path)
+    
+    # 2. docker-compose.yml
+    docker_compose_content = generate_docker_compose(stack, project_name)
+    docker_compose_path = f"docker-compose.yml"
+    await write_file(docker_compose_path, docker_compose_content)
+    created_files.append(docker_compose_path)
+    
+    # 3. GitHub Actions workflow
+    workflow_content = generate_github_workflow(stack, project_name)
+    workflow_path = f".github/workflows/ci-cd.yml"
+    await write_file(workflow_path, workflow_content)
+    created_files.append(workflow_path)
+    
+    # 4. Terraform main
+    terraform_main = generate_terraform_main(stack, project_name)
+    terraform_path = f"infra/{project_name}/main.tf"
+    await write_file(terraform_path, terraform_main)
+    created_files.append(terraform_path)
+    
+    # 5. Terraform variables
+    terraform_vars = generate_terraform_variables(stack, project_name)
+    terraform_vars_path = f"infra/{project_name}/variables.tf"
+    await write_file(terraform_vars_path, terraform_vars)
+    created_files.append(terraform_vars_path)
+    
+    # 6. Estado da infraestrutura
+    estado_path = f"infra/{project_name}/estado.json"
+    await write_file(estado_path, json.dumps(template_content, indent=2))
+    created_files.append(estado_path)
+    
+    return created_files
+
+
+def generate_dockerfile(stack: dict) -> str:
+    """
+    Gera Dockerfile baseado na stack
+    
+    Args:
+        stack: Informações da stack
+        
+    Returns:
+        str: Conteúdo do Dockerfile
+    """
+    language = stack.get("language", "NODE")
+    framework = stack.get("framework", "")
+    
+    if language == "NODE":
+        return f"""# Multi-stage build for Node.js {framework}
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --only=production && npm cache clean --force
+
+# Production stage
+FROM node:20-alpine
+RUN addgroup -g 1001 -S nodejs
+RUN adduser -S nodejs -u 1001
+WORKDIR /app
+COPY --from=builder --chown=nodejs:nodejs /app/node_modules ./node_modules
+COPY --from=builder --chown=nodejs:nodejs /app/package.json ./package.json
+COPY . .
+USER nodejs
+EXPOSE 3000
+CMD ["node", "dist/main.js"]
+"""
+    elif language == "PYTHON":
+        return f"""# Multi-stage build for Python {framework}
+FROM python:3.11-slim AS builder
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir --user -r requirements.txt
+
+# Production stage
+FROM python:3.11-slim
+RUN adduser --disabled-password --gecos '' appuser
+WORKDIR /app
+COPY --from=builder /root/.local /home/appuser/.local
+COPY . .
+USER appuser
+ENV PATH=/home/appuser/.local/bin:$PATH
+EXPOSE 8000
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+"""
+    elif language == "JAVA":
+        return f"""# Multi-stage build for Java {framework}
+FROM maven:3.9-openjdk-17 AS builder
+WORKDIR /app
+COPY pom.xml .
+RUN mvn dependency:go-offline
+COPY src ./src
+RUN mvn package -DskipTests
+
+# Production stage
+FROM openjdk:17-jre-slim
+RUN addgroup --system app && adduser --system app --group app
+WORKDIR /app
+COPY --from=builder /app/target/*.jar app.jar
+USER app:app
+EXPOSE 8080
+CMD ["java", "-jar", "app.jar"]
+"""
+    else:
+        return "# Dockerfile template - customize based on your stack\nFROM alpine:latest\nCMD [\"echo\", \"Hello World\"]"
+
+
+def generate_docker_compose(stack: dict, project_name: str) -> str:
+    """
+    Gera docker-compose.yml para desenvolvimento
+    
+    Args:
+        stack: Informações da stack
+        project_name: Nome do projeto
+        
+    Returns:
+        str: Conteúdo do docker-compose.yml
+    """
+    database = stack.get("database", "POSTGRES")
+    
+    return f"""version: '3.8'
+
+services:
+  app:
+    build: .
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=development
+      - DATABASE_URL={get_database_url(database)}
+    depends_on:
+      - db
+    volumes:
+      - .:/app
+      - /app/node_modules
+
+  db:
+    image: {get_database_image(database)}
+    environment:
+      - POSTGRES_DB={project_name}
+      - POSTGRES_USER=dev
+      - POSTGRES_PASSWORD=dev123
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+
+volumes:
+  postgres_data:
+  redis_data:
+"""
+
+
+def generate_github_workflow(stack: dict, project_name: str) -> str:
+    """
+    Gera workflow do GitHub Actions
+    
+    Args:
+        stack: Informações da stack
+        project_name: Nome do projeto
+        
+    Returns:
+        str: Conteúdo do workflow
+    """
+    language = stack.get("language", "NODE")
+    
+    return f"""name: CI/CD Pipeline
+
+on:
+  push:
+    branches: [main, develop]
+  pull_request:
+    branches: [main]
+
+env:
+  {get_environment_vars(language)}
+
+jobs:
+  test:
+    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 tests
+        run: {get_test_command(language)}
+      - name: Run linting
+        run: {get_lint_command(language)}
+
+  build:
+    needs: test
+    runs-on: ubuntu-latest
+    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: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          tags: ${{{{ secrets.CONTAINER_REGISTRY }}}}/{project_name}:${{{{ github.sha }}}}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+  deploy-dev:
+    needs: build
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/develop'
+    environment: development
+    steps:
+      - name: Deploy to development
+        run: echo "Deploy to development environment"
+
+  deploy-prod:
+    needs: build
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main'
+    environment: production
+    steps:
+      - name: Deploy to production
+        run: echo "Deploy to production environment"
+"""
+
+
+def calculate_initial_score(template_content: dict) -> int:
+    """
+    Calcula score inicial de validação
+    
+    Args:
+        template_content: Template preenchido
+        
+    Returns:
+        int: Score de 0-100
+    """
+    score = 0
+    max_score = 100
+    
+    # Stack definida (20 pontos)
+    if template_content["infraestrutura"]["stack"]["language"]:
+        score += 5
+    if template_content["infraestrutura"]["stack"]["framework"]:
+        score += 5
+    if template_content["infraestrutura"]["stack"]["database"]:
+        score += 5
+    if template_content["infraestrutura"]["stack"]["cloud_provider"]:
+        score += 5
+    
+    # Ambientes configurados (20 pontos)
+    envs = template_content["infraestrutura"]["ambientes"]
+    if envs.get("dev", {}).get("url"):
+        score += 7
+    if envs.get("staging", {}).get("url"):
+        score += 7
+    if envs.get("prod", {}).get("url"):
+        score += 6
+    
+    # CI/CD planejado (20 pontos)
+    if template_content["infraestrutura"]["ci_cd"]["provider"]:
+        score += 20
+    
+    # Containerização (15 pontos)
+    if template_content["infraestrutura"]["container"]["registry"]:
+        score += 5
+    if template_content["infraestrutura"]["container"]["image_name"]:
+        score += 5
+    if template_content["infraestrutura"]["container"]["latest_tag"]:
+        score += 5
+    
+    # IaC definida (15 pontos)
+    if template_content["infraestrutura"]["iac"]["tool"]:
+        score += 5
+    if template_content["infraestrutura"]["iac"]["state_location"]:
+        score += 5
+    if template_content["infraestrutura"]["iac"]["coverage"] >= 0:
+        score += 5
+    
+    # Compliance (10 pontos)
+    compliance = template_content["compliance"]
+    if compliance.get("security_scan"):
+        score += 3
+    if compliance.get("secrets_management"):
+        score += 2
+    if compliance.get("backup_configured"):
+        score += 2
+    if compliance.get("monitoring_enabled"):
+        score += 3
+    
+    return score
+
+
+def generate_next_steps(template_content: dict, score: int) -> list[str]:
+    """
+    Gera próximos passos baseados no template e score
+    
+    Args:
+        template_content: Template preenchido
+        score: Score de validação
+        
+    Returns:
+        list[str]: Próximos passos recomendados
+    """
+    next_steps = []
+    
+    if score < 80:
+        next_steps.append("Complete os campos obrigatórios para atingir score ≥ 80")
+    
+    # Verificar stack
+    if not template_content["infraestrutura"]["stack"]["framework"]:
+        next_steps.append("Defina o framework da aplicação")
+    
+    # Verificar CI/CD
+    if template_content["infraestrutura"]["ci_cd"]["status"] == "not_configured":
+        next_steps.append("Configure o pipeline de CI/CD")
+    
+    # Verificar containerização
+    if not template_content["infraestrutura"]["container"]["registry"]:
+        next_steps.append("Configure o container registry")
+    
+    # Verificar IaC
+    if template_content["infraestrutura"]["iac"]["coverage"] == 0:
+        next_steps.append("Implemente infraestrutura como código")
+    
+    # Verificar compliance
+    compliance = template_content["compliance"]
+    if not compliance["security_scan"]:
+        next_steps.append("Configure security scanning")
+    if not compliance["monitoring_enabled"]:
+        next_steps.append("Configure monitoring e alertas")
+    
+    # Próximos passos padrão
+    next_steps.extend([
+        "Revise os arquivos gerados",
+        "Teste o ambiente de desenvolvimento",
+        "Configure as variáveis de ambiente",
+        "Execute o pipeline de CI/CD",
+        "Valide o deploy em staging"
+    ])
+    
+    return next_steps
+
+
+# FUNÇÕES AUXILIARES DE GERAÇÃO
+
+def get_database_url(database: str) -> str:
+    """Retorna URL de conexão com database"""
+    return {
+        "POSTGRES": "postgresql://dev:dev123@db:5432/dev",
+        "MYSQL": "mysql://dev:dev123@db:3306/dev",
+        "MONGO": "mongodb://dev:dev123@db:27017/dev",
+        "REDIS": "redis://redis:6379"
+    }.get(database, "postgresql://dev:dev123@db:5432/dev")
+
+
+def get_database_image(database: str) -> str:
+    """Retorna imagem Docker do database"""
+    return {
+        "POSTGRES": "postgres:15",
+        "MYSQL": "mysql:8",
+        "MONGO": "mongo:6",
+        "REDIS": "redis:7-alpine"
+    }.get(database, "postgres:15")
+
+
+def get_environment_vars(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_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_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")
+
+
+# EXEMPLO DE USO
+
+if __name__ == "__main__":
+    """
+    Exemplo de como a função seria chamada no MCP:
+    
+    result = await init_infrastructure_structure({
+        "project_name": "API Produtos",
+        "stack": {
+            "language": "NODE",
+            "framework": "NEST",
+            "database": "POSTGRES",
+            "cloud_provider": "AWS"
+        },
+        "environments": ["dev", "staging", "prod"],
+        "compliance_requirements": {
+            "security_scan": True,
+            "monitoring_enabled": True
+        },
+        "team_contact": "devops@empresa.com"
+    })
+    
+    print(f"Success: {result['success']}")
+    print(f"Score: {result['validation_score']}")
+    print(f"Files created: {len(result['created_files'])}")
+    """
+    
+    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.")