@maestro-ai/mcp-server 1.2.0 → 2.0.0

package/dist/content/skills/specialist-arquitetura-software/mcp_functions/process_architecture.py

@@ -0,0 +1,279 @@
+# Referência MCP: process_architecture.py
+# Função de processamento para especialista de arquitetura
+# NOTA: Este é um arquivo de referência - a execução é feita no MCP
+
+async def process_architecture_to_next_phase(params):
+    """
+    Processa artefato de arquitetura e prepara para próxima fase
+    
+    Args:
+        params (dict): Parâmetros de processamento
+            - architecture_path: Caminho do arquivo de arquitetura
+            - validation_score: Score de validação obtido
+            - project_context: Contexto completo do projeto
+            - next_phase: Próxima fase do workflow
+    
+    Returns:
+        dict: Resultado do processamento com contexto para próxima fase
+    """
+    
+    architecture_path = params.get('architecture_path', 'docs/06-arquitetura/arquitetura.md')
+    validation_score = params.get('validation_score', 0)
+    next_phase = params.get('next_phase', 'seguranca')
+    
+    # Verificar se score mínimo foi atingido
+    if validation_score < 75:
+        return {
+            'success': False,
+            'reason': 'Score de validação insuficiente',
+            'required_score': 75,
+            'current_score': validation_score,
+            'recommendations': [
+                'Revisar seções incompletas',
+                'Adicionar mais detalhes técnicos',
+                'Documentar decisões arquiteturais',
+                'Refinar SLOs e métricas'
+            ]
+        }
+    
+    # Extrair informações chave da arquitetura
+    architecture_summary = extract_architecture_summary(architecture_path)
+    
+    # Preparar contexto para próxima fase
+    next_phase_context = prepare_next_phase_context(architecture_summary, next_phase)
+    
+    # Gerar artefatos de transição
+    transition_artifacts = generate_transition_artifacts(architecture_summary, next_phase)
+    
+    # Atualizar contexto do projeto
+    updated_context = update_project_context(architecture_summary, params.get('project_context', {}))
+    
+    return {
+        'success': True,
+        'validation_score': validation_score,
+        'architecture_summary': architecture_summary,
+        'next_phase_context': next_phase_context,
+        'transition_artifacts': transition_artifacts,
+        'updated_context': updated_context,
+        'next_actions': get_next_phase_actions(next_phase, next_phase_context)
+    }
+
+def extract_architecture_summary(architecture_path):
+    """Extrai resumo da arquitetura"""
+    return {
+        'system_type': extract_system_type(architecture_path),
+        'architecture_pattern': extract_architecture_pattern(architecture_path),
+        'technology_stack': extract_technology_stack(architecture_path),
+        'key_decisions': extract_key_decisions(architecture_path),
+        'security_considerations': extract_security_considerations(architecture_path),
+        'performance_requirements': extract_performance_requirements(architecture_path),
+        'integration_points': extract_integration_points(architecture_path),
+        'deployment_strategy': extract_deployment_strategy(architecture_path)
+    }
+
+def prepare_next_phase_context(architecture_summary, next_phase):
+    """Prepara contexto para próxima fase"""
+    
+    if next_phase == 'seguranca':
+        return prepare_security_context(architecture_summary)
+    elif next_phase == 'frontend':
+        return prepare_frontend_context(architecture_summary)
+    elif next_phase == 'backend':
+        return prepare_backend_context(architecture_summary)
+    else:
+        return prepare_generic_context(architecture_summary)
+
+def prepare_security_context(architecture_summary):
+    """Prepara contexto para fase de segurança"""
+    return {
+        'phase': 'seguranca',
+        'inputs_from_architecture': {
+            'system_architecture': architecture_summary['architecture_pattern'],
+            'technology_stack': architecture_summary['technology_stack'],
+            'integration_points': architecture_summary['integration_points'],
+            'deployment_strategy': architecture_summary['deployment_strategy'],
+            'security_considerations': architecture_summary['security_considerations']
+        },
+        'security_focus_areas': [
+            'OWASP Top 10 compliance',
+            'Authentication and authorization strategy',
+            'Data protection and encryption',
+            'Network security',
+            'Compliance requirements'
+        ],
+        'required_deliverables': [
+            'Security checklist',
+            'Threat model',
+            'Compliance plan',
+            'Security monitoring strategy'
+        ]
+    }
+
+def prepare_frontend_context(architecture_summary):
+    """Prepara contexto para fase de frontend"""
+    return {
+        'phase': 'frontend',
+        'inputs_from_architecture': {
+            'frontend_stack': architecture_summary['technology_stack'].get('frontend', {}),
+            'system_architecture': architecture_summary['architecture_pattern'],
+            'integration_points': architecture_summary['integration_points'],
+            'performance_requirements': architecture_summary['performance_requirements']
+        },
+        'frontend_focus_areas': [
+            'Component architecture',
+            'State management',
+            'API integration',
+            'Performance optimization',
+            'Accessibility compliance'
+        ],
+        'required_deliverables': [
+            'Component library',
+            'Page templates',
+            'API client',
+            'Test suite'
+        ]
+    }
+
+def prepare_backend_context(architecture_summary):
+    """Prepara contexto para fase de backend"""
+    return {
+        'phase': 'backend',
+        'inputs_from_architecture': {
+            'backend_stack': architecture_summary['technology_stack'].get('backend', {}),
+            'database_design': architecture_summary['technology_stack'].get('database', {}),
+            'system_architecture': architecture_summary['architecture_pattern'],
+            'integration_points': architecture_summary['integration_points']
+        },
+        'backend_focus_areas': [
+            'API design and implementation',
+            'Business logic',
+            'Data persistence',
+            'Integration with external services',
+            'Performance optimization'
+        ],
+        'required_deliverables': [
+            'API endpoints',
+            'Business services',
+            'Data models',
+            'Integration tests'
+        ]
+    }
+
+def prepare_generic_context(architecture_summary):
+    """Prepara contexto genérico para qualquer fase"""
+    return {
+        'phase': 'generic',
+        'architecture_overview': architecture_summary,
+        'key_decisions': architecture_summary['key_decisions'],
+        'technology_stack': architecture_summary['technology_stack'],
+        'integration_points': architecture_summary['integration_points']
+    }
+
+def generate_transition_artifacts(architecture_summary, next_phase):
+    """Gera artefatos de transição para próxima fase"""
+    
+    artifacts = {
+        'context_update': generate_context_update(architecture_summary),
+        'phase_briefing': generate_phase_briefing(architecture_summary, next_phase),
+        'checklist_transfer': generate_checklist_transfer(architecture_summary, next_phase)
+    }
+    
+    if next_phase == 'seguranca':
+        artifacts['security_briefing'] = generate_security_briefing(architecture_summary)
+    elif next_phase == 'frontend':
+        artifacts['frontend_briefing'] = generate_frontend_briefing(architecture_summary)
+    elif next_phase == 'backend':
+        artifacts['backend_briefing'] = generate_backend_briefing(architecture_summary)
+    
+    return artifacts
+
+def generate_context_update(architecture_summary):
+    """Gera atualização de contexto do projeto"""
+    return {
+        'architecture_decisions': architecture_summary['key_decisions'],
+        'technology_stack': architecture_summary['technology_stack'],
+        'system_boundaries': architecture_summary['integration_points'],
+        'performance_targets': architecture_summary['performance_requirements'],
+        'last_updated': datetime.now().isoformat()
+    }
+
+def generate_phase_briefing(architecture_summary, next_phase):
+    """Gera briefing para próxima fase"""
+    return {
+        'target_phase': next_phase,
+        'architecture_inputs': {
+            'pattern': architecture_summary['architecture_pattern'],
+            'stack': architecture_summary['technology_stack'],
+            'decisions': architecture_summary['key_decisions']
+        },
+        'focus_areas': get_phase_focus_areas(next_phase),
+        'success_criteria': get_phase_success_criteria(next_phase)
+    }
+
+def generate_checklist_transfer(architecture_summary, next_phase):
+    """Gera transferência de checklist para próxima fase"""
+    return {
+        'architecture_compliance': {
+            'c4_diagrams_complete': True,
+            'adrs_documented': True,
+            'slos_defined': True,
+            'security_considered': True
+        },
+        'phase_requirements': get_phase_requirements(next_phase),
+        'dependencies': get_phase_dependencies(next_phase)
+    }
+
+def get_next_phase_actions(next_phase, context):
+    """Retorna ações para próxima fase"""
+    
+    base_actions = [
+        f"Iniciar especialista de {next_phase}",
+        "Transferir contexto da arquitetura",
+        "Validar inputs recebidos",
+        "Executar workflow da fase"
+    ]
+    
+    if next_phase == 'seguranca':
+        base_actions.extend([
+            "Revisar considerações de segurança da arquitetura",
+            "Identificar requisitos de compliance",
+            "Iniciar threat modeling"
+        ])
+    elif next_phase == 'frontend':
+        base_actions.extend([
+            "Configurar ambiente de desenvolvimento frontend",
+            "Preparar design system",
+            "Configurar integração com API"
+        ])
+    elif next_phase == 'backend':
+        base_actions.extend([
+            "Configurar ambiente de desenvolvimento backend",
+            "Preparar estrutura de banco de dados",
+            "Configurar endpoints de API"
+        ])
+    
+    return base_actions
+
+# Funções auxiliares (simuladas para referência)
+def extract_system_type(path): return "web_application"
+def extract_architecture_pattern(path): return "monolith_modular"
+def extract_technology_stack(path): 
+    return {
+        'frontend': {'framework': 'React', 'language': 'TypeScript'},
+        'backend': {'framework': 'Express', 'language': 'TypeScript'},
+        'database': {'primary': 'PostgreSQL', 'cache': 'Redis'}
+    }
+def extract_key_decisions(path): return ["ADR-001: Monolith Modular", "ADR-002: PostgreSQL"]
+def extract_security_considerations(path): return ["OAuth2", "RBAC", "TLS"]
+def extract_performance_requirements(path): return ["p95 < 200ms", "99.9% uptime"]
+def extract_integration_points(path): return ["Payment Gateway", "Email Service"]
+def extract_deployment_strategy(path): return "Docker + AWS"
+def get_phase_focus_areas(phase): return ["Area 1", "Area 2"]
+def get_phase_success_criteria(phase): return ["Criteria 1", "Criteria 2"]
+def get_phase_requirements(phase): return ["Requirement 1", "Requirement 2"]
+def get_phase_dependencies(phase): return ["Dependency 1", "Dependency 2"]
+def generate_security_briefing(summary): return {"security": "briefing"}
+def generate_frontend_briefing(summary): return {"frontend": "briefing"}
+def generate_backend_briefing(summary): return {"backend": "briefing"}
+
+from datetime import datetime

package/dist/content/skills/specialist-arquitetura-software/mcp_functions/validate_architecture.py

@@ -0,0 +1,302 @@
+# Referência MCP: validate_architecture.py
+# Função de validação para especialista de arquitetura
+# NOTA: Este é um arquivo de referência - a execução é feita no MCP
+
+async def validate_architecture_quality(params):
+    """
+    Valida qualidade do artefato de arquitetura
+    
+    Args:
+        params (dict): Parâmetros de validação
+            - architecture_path: Caminho do arquivo de arquitetura
+            - project_context: Contexto do projeto
+            - validation_level: Nível de validação (basic/strict/comprehensive)
+    
+    Returns:
+        dict: Resultado da validação com score e recomendações
+    """
+    
+    validation_level = params.get('validation_level', 'basic')
+    architecture_path = params.get('architecture_path', 'docs/06-arquitetura/arquitetura.md')
+    
+    # Critérios de validação baseados no nível
+    if validation_level == 'basic':
+        criteria = get_basic_validation_criteria()
+    elif validation_level == 'strict':
+        criteria = get_strict_validation_criteria()
+    else:
+        criteria = get_comprehensive_validation_criteria()
+    
+    # Executar validações
+    validation_results = {
+        'structure_validation': validate_structure(architecture_path, criteria),
+        'content_validation': validate_content(architecture_path, criteria),
+        'quality_validation': validate_quality(architecture_path, criteria),
+        'consistency_validation': validate_consistency(architecture_path, criteria)
+    }
+    
+    # Calcular score
+    total_score = calculate_validation_score(validation_results)
+    
+    # Gerar recomendações
+    recommendations = generate_recommendations(validation_results, total_score)
+    
+    return {
+        'validation_level': validation_level,
+        'total_score': total_score,
+        'passed': total_score >= 75,
+        'validation_results': validation_results,
+        'recommendations': recommendations,
+        'next_actions': get_next_actions(total_score, validation_results)
+    }
+
+def get_basic_validation_criteria():
+    """Critérios de validação básica"""
+    return {
+        'required_sections': [
+            '## Sumário Executivo',
+            '## 1. Visão Arquitetural',
+            '## 2. Arquitetura C4',
+            '## 3. Stack Tecnológica',
+            '## 4. Decisões Arquiteturais',
+            '## 5. Segurança',
+            '## Checklist de Qualidade'
+        ],
+        'minimum_checkboxes': 30,
+        'minimum_adrs': 2,
+        'minimum_slos': 3
+    }
+
+def get_strict_validation_criteria():
+    """Critérios de validação estrita"""
+    return {
+        'required_sections': [
+            '## Sumário Executivo',
+            '## 1. Visão Arquitetural',
+            '## 2. Arquitetura C4',
+            '## 3. Stack Tecnológica',
+            '## 4. Decisões Arquiteturais',
+            '## 5. Segurança',
+            '## 6. Performance e Escalabilidade',
+            '## 7. Monitoramento e Observabilidade',
+            '## 8. Riscos e Mitigações',
+            '## 9. Roadmap de Implementação',
+            '## Checklist de Qualidade'
+        ],
+        'minimum_checkboxes': 50,
+        'minimum_adrs': 3,
+        'minimum_slos': 5,
+        'requires_c4_levels': [1, 2, 3],
+        'requires_security_details': True,
+        'requires_performance_metrics': True
+    }
+
+def get_comprehensive_validation_criteria():
+    """Critérios de validação abrangente"""
+    return {
+        'required_sections': [
+            '## Sumário Executivo',
+            '## 1. Visão Arquitetural',
+            '## 2. Arquitetura C4',
+            '## 3. Stack Tecnológica',
+            '## 4. Decisões Arquiteturais',
+            '## 5. Segurança',
+            '## 6. Performance e Escalabilidade',
+            '## 7. Monitoramento e Observabilidade',
+            '## 8. Riscos e Mitigações',
+            '## 9. Roadmap de Implementação',
+            '## 10. Glossário',
+            '## Checklist de Qualidade'
+        ],
+        'minimum_checkboxes': 70,
+        'minimum_adrs': 5,
+        'minimum_slos': 8,
+        'requires_c4_levels': [1, 2, 3],
+        'requires_security_details': True,
+        'requires_performance_metrics': True,
+        'requires_monitoring_plan': True,
+        'requires_risk_assessment': True,
+        'requires_implementation_timeline': True,
+        'requires_glossary': True
+    }
+
+def validate_structure(architecture_path, criteria):
+    """Valida estrutura do documento"""
+    results = {
+        'has_all_sections': False,
+        'missing_sections': [],
+        'section_count': 0,
+        'checkbox_count': 0,
+        'adr_count': 0,
+        'slo_count': 0
+    }
+    
+    # Verificar seções obrigatórias
+    required_sections = criteria.get('required_sections', [])
+    missing_sections = []
+    
+    for section in required_sections:
+        if not check_section_exists(architecture_path, section):
+            missing_sections.append(section)
+    
+    results['has_all_sections'] = len(missing_sections) == 0
+    results['missing_sections'] = missing_sections
+    results['section_count'] = count_sections(architecture_path)
+    results['checkbox_count'] = count_checkboxes(architecture_path)
+    results['adr_count'] = count_adrs(architecture_path)
+    results['slo_count'] = count_slos(architecture_path)
+    
+    return results
+
+def validate_content(architecture_path, criteria):
+    """Valida conteúdo do documento"""
+    results = {
+        'has_executive_summary': False,
+        'has_c4_diagrams': False,
+        'has_stack_justification': False,
+        'has_security_strategy': False,
+        'has_performance_considerations': False,
+        'has_risk_mitigation': False,
+        'word_count': 0,
+        'completeness_score': 0
+    }
+    
+    # Verificar conteúdo específico
+    results['has_executive_summary'] = check_executive_summary_quality(architecture_path)
+    results['has_c4_diagrams'] = check_c4_diagrams(architecture_path, criteria)
+    results['has_stack_justification'] = check_stack_justification(architecture_path)
+    results['has_security_strategy'] = check_security_strategy(architecture_path, criteria)
+    results['has_performance_considerations'] = check_performance_considerations(architecture_path, criteria)
+    results['has_risk_mitigation'] = check_risk_mitigation(architecture_path, criteria)
+    results['word_count'] = count_words(architecture_path)
+    results['completeness_score'] = calculate_completeness_score(architecture_path, criteria)
+    
+    return results
+
+def validate_quality(architecture_path, criteria):
+    """Valida qualidade do documento"""
+    results = {
+        'clarity_score': 0,
+        'consistency_score': 0,
+        'technical_accuracy_score': 0,
+        'feasibility_score': 0,
+        'overall_quality_score': 0
+    }
+    
+    # Avaliar qualidade
+    results['clarity_score'] = assess_clarity(architecture_path)
+    results['consistency_score'] = assess_consistency(architecture_path)
+    results['technical_accuracy_score'] = assess_technical_accuracy(architecture_path)
+    results['feasibility_score'] = assess_feasibility(architecture_path)
+    results['overall_quality_score'] = calculate_overall_quality(results)
+    
+    return results
+
+def validate_consistency(architecture_path, criteria):
+    """Valida consistência com outros artefatos"""
+    results = {
+        'consistent_with_prd': False,
+        'consistent_with_requirements': False,
+        'consistent_with_domain_model': False,
+        'consistent_with_ux_design': False,
+        'cross_reference_score': 0
+    }
+    
+    # Verificar consistência
+    results['consistent_with_prd'] = check_consistency_with_prd(architecture_path)
+    results['consistent_with_requirements'] = check_consistency_with_requirements(architecture_path)
+    results['consistent_with_domain_model'] = check_consistency_with_domain_model(architecture_path)
+    results['consistent_with_ux_design'] = check_consistency_with_ux_design(architecture_path)
+    results['cross_reference_score'] = calculate_cross_reference_score(architecture_path)
+    
+    return results
+
+def calculate_validation_score(validation_results):
+    """Calcula score total de validação"""
+    weights = {
+        'structure_validation': 0.3,
+        'content_validation': 0.3,
+        'quality_validation': 0.2,
+        'consistency_validation': 0.2
+    }
+    
+    scores = {
+        'structure_validation': calculate_structure_score(validation_results['structure_validation']),
+        'content_validation': calculate_content_score(validation_results['content_validation']),
+        'quality_validation': validation_results['quality_validation']['overall_quality_score'],
+        'consistency_validation': calculate_consistency_score(validation_results['consistency_validation'])
+    }
+    
+    total_score = 0
+    for category, weight in weights.items():
+        total_score += scores[category] * weight
+    
+    return round(total_score, 2)
+
+def generate_recommendations(validation_results, total_score):
+    """Gera recomendações baseadas nos resultados"""
+    recommendations = []
+    
+    if total_score < 60:
+        recommendations.append("Revisar completamente a estrutura do documento")
+        recommendations.append("Adicionar mais detalhes técnicos")
+        recommendations.append("Documentar decisões arquiteturais")
+    elif total_score < 75:
+        recommendations.append("Completar seções obrigatórias")
+        recommendations.append("Adicionar mais ADRs")
+        recommendations.append("Refinar SLOs")
+    elif total_score < 90:
+        recommendations.append("Adicionar exemplos específicos")
+        recommendations.append("Incluir métricas detalhadas")
+        recommendations.append("Refinar roadmap de implementação")
+    else:
+        recommendations.append("Excelente qualidade! Considerar como template")
+        recommendations.append("Documentar lessons learned")
+        recommendations.append("Compartilhar com time")
+    
+    return recommendations
+
+def get_next_actions(total_score, validation_results):
+    """Próximas ações baseadas no score"""
+    if total_score >= 75:
+        return [
+            "Arquitetura validada e pronta para implementação",
+            "Avançar para próxima fase (Segurança)",
+            "Compartilhar com time técnico",
+            "Iniciar implementação baseada no roadmap"
+        ]
+    else:
+        return [
+            "Revisar e melhorar arquitetura",
+            "Completar validações pendentes",
+            "Obter feedback de stakeholders",
+            "Refinar decisões arquiteturais"
+        ]
+
+# Funções auxiliares (simuladas para referência)
+def check_section_exists(path, section): return True
+def count_sections(path): return 10
+def count_checkboxes(path): return 50
+def count_adrs(path): return 3
+def count_slos(path): return 5
+def check_executive_summary_quality(path): return True
+def check_c4_diagrams(path, criteria): return True
+def check_stack_justification(path): return True
+def check_security_strategy(path, criteria): return True
+def check_performance_considerations(path, criteria): return True
+def check_risk_mitigation(path, criteria): return True
+def count_words(path): return 1500
+def calculate_completeness_score(path, criteria): return 0.8
+def assess_clarity(path): return 85
+def assess_consistency(path): return 80
+def assess_technical_accuracy(path): return 90
+def assess_feasibility(path): return 85
+def calculate_overall_quality(scores): return 85
+def calculate_structure_score(results): return 90
+def calculate_content_score(results): return 85
+def calculate_consistency_score(results): return 80
+def check_consistency_with_prd(path): return True
+def check_consistency_with_requirements(path): return True
+def check_consistency_with_domain_model(path): return True
+def check_consistency_with_ux_design(path): return True
+def calculate_cross_reference_score(path): return 85