@maestro-ai/mcp-server 1.2.0 → 2.0.0

package/dist/content/skills/specialist-acessibilidade/mcp_functions/init_accessibility_audit.py

@@ -0,0 +1,675 @@
+#!/usr/bin/env python3
+"""
+Referência MCP: Inicialização de Auditoria de Acessibilidade
+
+Esta função inicia uma auditoria de acessibilidade WCAG 2.1 AA para um projeto,
+criando estrutura base, executando testes automatizados e gerando relatório inicial.
+
+NOTA: Este é um arquivo de referência. A execução real deve ser
+implementada no servidor MCP externo.
+"""
+
+from typing import Dict, List, Optional
+from pathlib import Path
+import json
+from datetime import datetime
+import subprocess
+import re
+
+class AccessibilityAuditor:
+    """Inicializador de auditoria de acessibilidade"""
+    
+    def __init__(self, project_path: str):
+        self.project_path = Path(project_path)
+        self.audit_results = {}
+        
+    def init_audit(self, config: Dict) -> Dict:
+        """
+        Inicia auditoria de acessibilidade
+        
+        Args:
+            config: Dicionário com configuração da auditoria
+                - project_type: "web|mobile|desktop"
+                - wcag_level: "AA|AAA"
+                - target_browsers: ["chrome", "firefox", "safari"]
+                - screen_readers: ["nvda", "voiceover", "jaws"]
+                - include_automated: boolean
+                - include_manual: boolean
+                
+        Returns:
+            Dict com resultado da inicialização
+        """
+        
+        project_type = config.get("project_type", "web")
+        wcag_level = config.get("wcag_level", "AA")
+        target_browsers = config.get("target_browsers", ["chrome", "firefox", "safari"])
+        screen_readers = config.get("screen_readers", ["nvda", "voiceover", "jaws"])
+        include_automated = config.get("include_automated", True)
+        include_manual = config.get("include_manual", True)
+        
+        # Criar estrutura de diretórios
+        directories = self._create_audit_structure()
+        
+        # Executar testes automatizados
+        automated_results = {}
+        if include_automated:
+            automated_results = self._run_automated_tests(
+                project_type, 
+                target_browsers, 
+                wcag_level
+            )
+        
+        # Preparar testes manuais
+        manual_tests = {}
+        if include_manual:
+            manual_tests = self._prepare_manual_tests(
+                screen_readers, 
+                wcag_level
+            )
+        
+        # Gerar relatório inicial
+        report = {
+            "status": "success",
+            "audit": {
+                "timestamp": datetime.now().isoformat(),
+                "project_type": project_type,
+                "wcag_level": wcag_level,
+                "target_browsers": target_browsers,
+                "screen_readers": screen_readers,
+                "automated_tests": automated_results,
+                "manual_tests": manual_tests
+            },
+            "created": {
+                "directories": directories,
+                "test_files": self._create_test_files(),
+                "checklists": self._create_checklists()
+            },
+            "next_steps": self._get_next_steps(),
+            "estimated_duration": self._estimate_duration(
+                include_automated, 
+                include_manual
+            )
+        }
+        
+        return report
+    
+    def _create_audit_structure(self) -> List[str]:
+        """Cria estrutura de diretórios para auditoria"""
+        
+        base_dirs = [
+            "audit-results",
+            "audit-results/automated",
+            "audit-results/manual",
+            "audit-results/screenshots",
+            "audit-results/reports",
+            "checklists",
+            "templates",
+            "examples"
+        ]
+        
+        created_dirs = []
+        for dir_path in base_dirs:
+            full_path = self.project_path / dir_path
+            full_path.mkdir(parents=True, exist_ok=True)
+            created_dirs.append(str(full_path))
+        
+        return created_dirs
+    
+    def _run_automated_tests(self, project_type: str, browsers: List[str], wcag_level: str) -> Dict:
+        """Executa testes automatizados de acessibilidade"""
+        
+        results = {
+            "tool": "axe-core",
+            "version": "4.8.2",
+            "browsers_tested": browsers,
+            "violations": [],
+            "passes": [],
+            "incomplete": [],
+            "score": 0
+        }
+        
+        try:
+            # Simular execução do axe-core
+            # Em implementação real, usaria:
+            # npx axe --report-path=audit-results/automated/axe-report.html
+            
+            # Resultados simulados
+            simulated_violations = [
+                {
+                    "id": "color-contrast",
+                    "impact": "critical",
+                    "description": "Elements must have sufficient color contrast",
+                    "count": 3,
+                    "nodes": ["button.btn-primary", "span.highlight", "div.card"]
+                },
+                {
+                    "id": "keyboard-navigation",
+                    "impact": "serious",
+                    "description": "Some elements are not keyboard accessible",
+                    "count": 2,
+                    "nodes": ["div.dropdown", "span.modal-trigger"]
+                },
+                {
+                    "id": "missing-alt-text",
+                    "impact": "serious",
+                    "description": "Images missing alternative text",
+                    "count": 5,
+                    "nodes": ["img.hero", "img.product-1", "img.product-2"]
+                }
+            ]
+            
+            simulated_passes = [
+                {
+                    "id": "semantic-structure",
+                    "description": "Semantic HTML structure is good",
+                    "count": 15
+                },
+                {
+                    "id": "form-labels",
+                    "description": "Form elements have proper labels",
+                    "count": 8
+                }
+            ]
+            
+            results["violations"] = simulated_violations
+            results["passes"] = simulated_passes
+            results["incomplete"] = simulated_incomplete
+            
+            # Calcular score
+            total_issues = sum(v["count"] for v in simulated_violations)
+            total_passes = sum(p["count"] for p in simulated_passes)
+            total_elements = total_issues + total_passes + len(simulated_incomplete)
+            
+            if total_elements > 0:
+                results["score"] = max(0, 100 - (total_issues * 5))
+            
+        except Exception as e:
+            results["error"] = str(e)
+        
+        return results
+    
+    def _run_contrast_tests(self, project_type: str) -> Dict:
+        """Executa testes de contraste de cores"""
+        
+        results = {
+            "tool": "color-contrast-checker",
+            "tested_elements": [],
+            "contrast_issues": [],
+            "passed_elements": [],
+            "score": 0
+        }
+        
+        try:
+            # Simular verificação de contraste
+            simulated_tests = [
+                {
+                    "element": "button.btn-primary",
+                    "foreground": "#6B9BD1",
+                    "background": "#4A90E2",
+                    "ratio": 3.2,
+                    "wcag_level": "FAIL"
+                },
+                {
+                    "element": "span.highlight",
+                    "foreground": "#CCCCCC",
+                    "background": "#FFFFFF",
+                    "ratio": 1.6,
+                    "wcag_level": "FAIL"
+                },
+                {
+                    "element": "div.card",
+                    "foreground": "#333333",
+                    "background": "#FFFFFF",
+                    "ratio": 12.6,
+                    "wcag_level": "PASS"
+                }
+            ]
+            
+            results["tested_elements"] = simulated_tests
+            results["contrast_issues"] = [
+                t for t in simulated_tests if t["wcag_level"] == "FAIL"
+            ]
+            results["passed_elements"] = [
+                t for t in simulated_tests if t["wcag_level"] == "PASS"
+            ]
+            
+            # Calcular score
+            total_elements = len(simulated_tests)
+            passed_elements = len(results["passed_elements"])
+            
+            if total_elements > 0:
+                results["score"] = (passed_elements / total_elements) * 100
+            
+        except Exception as e:
+            results["error"] = str(e)
+        
+        return results
+    
+    def _run_html_validation(self, project_type: str) -> Dict:
+        """Executa validação HTML semântico"""
+        
+        results = {
+            "tool": "html-validator",
+            "validator": "W3C Markup Validation Service",
+            "errors": [],
+            "warnings": [],
+            "score": 0
+        }
+        
+        try:
+            # Simular validação HTML
+            simulated_errors = [
+                {
+                    "line": 15,
+                    "column": 25,
+                    "message": "Element 'div' not allowed as child of element 'p'",
+                    "type": "error"
+                },
+                {
+                    "line": 23,
+                    "column": 30,
+                    "message": "Attribute 'role' not allowed on element 'span'",
+                    "type": "error"
+                }
+            ]
+            
+            simulated_warnings = [
+                {
+                    "line": 10,
+                    "column": 20,
+                    "message": "Consider adding a 'lang' attribute",
+                    "type": "warning"
+                }
+            ]
+            
+            results["errors"] = simulated_errors
+            results["warnings"] = simulated_warnings
+            
+            # Calcular score
+            total_issues = len(simulated_errors) + len(simulated_warnings)
+            if total_issues == 0:
+                results["score"] = 100
+            elif total_issues <= 2:
+                results["score"] = 90
+            else:
+                results["score"] = max(0, 100 - (total_issues * 10))
+            
+        except Exception as e:
+            results["error"] = str(e)
+        
+        return results
+    
+    def _run_keyboard_tests(self, project_type: str) -> Dict:
+        """Executa testes de navegação por teclado"""
+        
+        results = {
+            "tool": "keyboard-navigation-tester",
+            "tested_elements": [],
+            "keyboard_issues": [],
+            "passed_elements": [],
+            "score": 0
+        }
+        
+        try:
+            # Simular testes de teclado
+            simulated_tests = [
+                {
+                    "element": "main-navigation",
+                    "tab_accessible": True,
+                    "escape_functional": True,
+                    "focus_visible": True,
+                    "order_logical": True
+                },
+                {
+                    "element": "modal-overlay",
+                    "tab_accessible": False,
+                    "escape_functional": False,
+                    "focus_trap": True,
+                    "order_logical": False
+                },
+                {
+                    "element": "form-fields",
+                    "tab_accessible": True,
+                    "escape_functional": True,
+                    "focus_visible": True,
+                    "order_logical": True
+                }
+            ]
+            
+            results["tested_elements"] = simulated_tests
+            results["keyboard_issues"] = [
+                t for t in simulated_tests 
+                if not t["tab_accessible"] or not t["escape_functional"] or t["focus_trap"]
+            ]
+            results["passed_elements"] = [
+                t for t in simulated_tests 
+                if t["tab_accessible"] and t["escape_functional"] and not t["focus_trap"]
+            ]
+            
+            # Calcular score
+            total_elements = len(simulated_tests)
+            passed_elements = len(results["passed_elements"])
+            
+            if total_elements > 0:
+                results["score"] = (passed_elements / total_elements) * 100
+            
+        except Exception as e:
+            results["error"] = str(e)
+        
+        return results
+    
+    def _prepare_manual_tests(self, screen_readers: List[str], wcag_level: str) -> Dict:
+        """Prepara testes manuais"""
+        
+        return {
+            "screen_readers": screen_readers,
+            "wcag_level": wcag_level,
+            "checklist_template": "checklist-acessibilidade.md",
+            "report_template": "relatorio-acessibilidade.md",
+            "test_scenarios": [
+                "keyboard-navigation",
+                "screen-reader-navigation",
+                "zoom-200%",
+                "high-contrast-mode",
+                "form-accessibility",
+                "color-contrast"
+            ],
+            "tools_needed": [
+                "NVDA (Windows)",
+                "VoiceOver (macOS)",
+                "JAWS (Windows)",
+                "Chrome DevTools",
+                "Firefox Developer Tools",
+                "WAVE Extension"
+            ]
+        }
+    
+    def _create_test_files(self) -> List[str]:
+        """Cria arquivos de teste"""
+        
+        test_files = [
+            "test-keyboard.html",
+            "test-screenreader.html",
+            "test-contrast.html",
+            "test-zoom.html"
+        ]
+        
+        created_files = []
+        for file_name in test_files:
+            file_path = self.project_path / "audit-results" / "tests" / file_name
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            # Conteúdo básico do arquivo de teste
+            if "keyboard" in file_name:
+                content = self._generate_keyboard_test_html()
+            elif "screenreader" in file_name:
+                content = self._generate_screenreader_test_html()
+            elif "contrast" in file_name:
+                content = self._generate_contrast_test_html()
+            elif "zoom" in file_name:
+                content = self._generate_zoom_test_html()
+            else:
+                content = "<p>Test file</p>"
+            
+            file_path.write_text(content, encoding='utf-8')
+            created_files.append(str(file_path))
+        
+        return created_files
+    
+    def _create_checklists(self) -> List[str]:
+        """Cria checklists de validação"""
+        
+        checklists = [
+            "wcag-aa-checklist.md",
+            "keyboard-checklist.md",
+            "screenreader-checklist.md",
+            "color-contrast-checklist.md"
+        ]
+        
+        created_checklists = []
+        for checklist_name in checklists:
+            checklist_path = self.project_path / "checklists" / checklist_name
+            checklist_path.parent.mkdir(parents=True, exist_ok=True)
+            
+            # Conteúdo básico do checklist
+            if "wcag-aa" in checklist_name:
+                content = self._generate_wcag_checklist()
+            elif "keyboard" in checklist_name:
+                content = self._generate_keyboard_checklist()
+            else:
+                content = f"# {checklist_name}\n\n## Itens a verificar\n- [ ] Item 1\n- [ ] Item 2"
+            
+            checklist_path.write_text(content, encoding='utf-8')
+            created_checklists.append(str(checklist_path))
+        
+        return created_checklists
+    
+    def _generate_wcag_checklist(self) -> str:
+        """Gera checklist WCAG 2.1 AA"""
+        return """# ♿ Checklist WCAG 2.1 AA
+
+## 📋 Metadados
+**Projeto:** [Nome do Projeto]  
+**Data:** [DD/MM/YYYY]  
+**Auditor:** [Nome do Auditor]  
+**Nível:** WCAG 2.1 AA  
+**Status:** [Em Progresso|Concluído|Reprovado]  
+**Score:** [XX]/111 pontos  
+
+## 🔍 1. Perceptível (38 pontos)
+
+### 1.1 Alternativas em Texto (15 pontos)
+- [ ] **1.1.1 - Conteúdo Não Textual**
+  - [ ] Imagens informativas têm alt text descritivo
+  - [ ] Imagens decorativas têm alt=""
+  - [ ] Ícones e botões têm texto alternativo
+  - [ ] Gráficos e diagramas têm descrições
+  - [ ] Vídeos têm legendas ou transcrição
+  - [ ] Áudio tem transcrição
+  - **Score:** [ ]/5
+
+### 1.2 Adaptável (8 pontos)
+- [ ] **1.2.1 - Informações e Relacionamentos**
+  - [ ] Estrutura lógica apresentada visualmente
+  - [ ] Sequência de leitura clara
+  - [ ] Relacionamentos entre conteúdo evidente
+  - **Score:** [ ]/3
+
+### 1.3 Distinguível (15 pontos)
+- [ ] **1.3.1 - Uso de Cor**
+  - [ ] Cor não é o único meio de identificação
+  - [ ] Links têm indicadores além da cor
+  - [ ] Campos de erro têm indicadores além da cor
+  - [ ] Estados são identificáveis sem cor
+  - **Score:** [ ]/3
+
+### 1.4 Distinguível (15 pontos)
+- [ ] **1.4.3 - Contraste (Mínimo)**
+  - [ ] Texto normal: contraste ≥ 4.5:1
+  - [ ] Texto grande: contraste ≥ 3:1
+  - [ ] Componentes de UI: contraste ≥ 3:1
+  - [ ] Gráficos: contraste adequado
+  - **Score:** [ ]/5
+
+## ⌨️ 2. Operável (31 pontos)
+
+### 2.1 Acessível por Teclado (10 pontos)
+- [ ] **2.1.1 - Teclado**
+  - [ ] Toda funcionalidade acessível por teclado
+  - [ ] Sem teclado trap
+  - [ ] Foco não fica preso
+  - [ ] Modo de navegação claro
+  - **Score:** [ ]/5
+
+- [ ] **2.1.2 - Sem Foco do Teclado**
+  - [ ] Foco do teclado não desativado
+  - [ ] Foco visível quando presente
+  - [ ] Foco pode ser programaticamente detectado
+  - **Score:** [ ]/3
+
+### 2.2 Tempo Suficiente (10 pontos)
+- [ ] **2.2.1 - Ajuste de Tempo**
+  - [ ] Timeout pode ser desativado
+  - [ ] Usuário pode ajustar tempo
+  - [ ] Aviso antes de expirar
+  - [ ] Tempo mínimo de 20 segundos
+  - **Score:** [ ]/5
+
+### 2.3 Navegação (11 pontos)
+- [ ] **2.4.1 - Ignorar Blocos**
+  - [ ] Link para pular navegação
+  - [ ] Blocos repetitivos podem ser ignorados
+  - [ ] Múltiplas formas de navegar
+  - **Score:** [ ]/3
+
+- [ ] **2.4.2 - Títulos de Página**
+  - [ ] Cada página tem título descritivo
+  - [ ] Títulos identificam conteúdo
+  - [ ] Títulos são únicos no site
+  - **Score:** [ ]/3
+
+- [ ] **2.4.3 - Foco e Ordem**
+  - [ ] Foco visível e claro
+  - [ ] Indicadores de foco acessíveis
+  - [ ] Ordem do foco programaticamente determinável
+  - **Score:** [ ]/3]
+
+## 🧠 3. Compreensível (30 pontos)
+
+### 3.1 Legível (10 pontos)
+- [ ] **3.1.1 - Idioma da Página**
+  - [ ] Idioma principal programaticamente determinado
+  - [ ] Mudanças de idioma marcadas
+  - [ ] Lang codes corretos
+  - **Score:** [ ]/3
+
+### 3.2 Previsível (10 pontos)
+- [ ] **3.2.1 - Foco**
+  - [ ] Mudança de foco não causa mudança de contexto
+  - [ ] Foco previsível e controlável
+  - **Score:** [ ]/2
+
+- [ ] **3.2.2 - Entrada do Usuário**
+  - [ ] Formulários não mudam ao preencher
+  - [ ] Ajuda contextual disponível
+  - [ ] Erros não causam perda de dados
+  - **Score:** [ ]/3
+
+### 3.3 Assistência (10 pontos)
+- [ ] **3.3.1 - Identificação de Erros**
+  - [ ] Erros são claramente identificados
+  - [ ] Mensagens de erro descritivas
+  - [ ] Localização dos erros indicada
+  - **Score:** [ ]/3
+
+- [ ] **3.3.2 - Rótulos ou Instruções**
+  - [ ] Campos têm rótulos descritivos
+  - [ ] Instruções claras disponíveis
+  - [ ] Formatos de entrada especificados
+  - [ ] Exemplos fornecidos quando necessário
+  - **Score:** [ ]/4
+
+- [ ] **3.3.3 - Sugestões de Erro**
+  - [ ] Sugestões para correção fornecidas
+  - [ ] Formatos válidos explicados
+  - [ ] Valores permitidos indicados
+  - **Score:** [ ]/3
+
+## 🔧 4. Robusto (12 pontos)
+
+### 4.1 Compatível (12 pontos)
+- [ ] **4.1.1 - Análise de Marcação**
+  - [ ] HTML semântico utilizado
+  - [ ] Elementos usados conforme propósito
+  - [ ] Validação HTML sem erros
+  - [ ] ARIA usado corretamente
+  - **Score:** [ ]/2
+
+- [ ] **4.1.2 - Nome, Função, Valor**
+  - [ ] Nome, função e valor programaticamente determináveis
+  - [ ] Estados podem ser definidos programaticamente
+  - [ ] Notificações de mudanças disponíveis
+  - **Score:** [ ]/3
+
+---
+
+## 📊 Score de Validação
+
+### Cálculo do Score
+```
+Score Total = WCAG Compliance (40) + Keyboard Navigation (20) + Screen Reader (20) + Color Contrast (10) + Semantic HTML (10)
+Mínimo para avanço: 80/100 pontos
+```
+
+### Nível de Conformidade
+- [ ] **WCAG 2.1 AAA:** 95-100 pontos
+- [ ] **WCAG 2.1 AA:** 80-94 pontos
+- [ ] **WCAG 2.1 A:** 60-79 pontos
+- [ ] **Não Conforme:** < 60 pontos
+
+### Status Final
+- [ ] **Aprovado:** Score ≥ 80
+- [ ] **Aprovado com Reservas:** Score 70-79
+- [ ] **Reprovado:** Score < 70
+
+---
+
+## 🚀 Próximos Passos
+
+### 1. Executar testes manuais
+- [ ] Teste de navegação por teclado em todas as páginas
+- [ ] Teste com leitor de tela (NVDA, VoiceOver, JAWS)
+- [ ] Verificar zoom 200% em diferentes componentes
+- [ ] Testar modo alto contraste
+
+### 2. Corrigir issues críticas
+- [ ] Corrigir problemas de contraste de cores
+- [ ] Implementar navegação completa por teclado
+- [ ] Adicionar textos alternativos faltantes
+- [ ] Corrigir foco não visível
+
+### 3. Gerar relatório completo
+- [ ] Compilar todos os resultados
+- [ ] Gerar gráficos e estatísticas
+- [ ] Documentar issues encontrados
+- [ Criar plano de ação
+
+### 4. Validar conformidade
+- [ ] Verificar se score mínimo foi atingido
+- [ ] Validar se issues críticas foram resolvidas
+- [ ] Testar com usuários reais se possível
+- [ ] Obter aprovação final
+
+---
+
+## 🎯 Estimativa de Duração
+
+### Fase 1: Preparação (30 minutos)
+- [ ] Configurar ambiente de teste
+- [ ] Instalar ferramentas necessárias
+- [ ] Preparar checklists
+- [ ] Definir escopo da auditoria
+
+### Fase 2: Execução (60-90 minutos)
+- [ ] Executar testes automatizados
+- [ ] Realizar testes manuais
+- [ ] Coletar resultados
+- [ ] Identificar issues
+
+### Fase 3: Relatório (30 minutos)
+- [ ] Compilar relatório completo
+- [ ] Gerar gráficos e estatísticas
+- [ ] Documentar recomendações
+- [ ] Criar plano de ação
+
+---
+
+**Status Final:** [ ] ✅ **INICIADO** | [ ] ✅ **CONCLUÍDO** | [ ] ❌ **ERRO**
+
+**Score Final:** [ ]/100 pontos  
+**Nível de Conformidade:** [WCAG 2.1 AA|A|AAA|Não Conforme]  
+**Data da Próxima Auditoria:** [DD/MM/YYYY]
+
+---
+
+*Este checklist deve ser usado durante a auditoria para garantir que todos os critérios WCAG 2.1 AA sejam verificados.*