mega-brain-ai 1.1.0

package/.claude/hooks/post_output_validator.py

@@ -0,0 +1,358 @@
+#!/usr/bin/env python3
+"""
+Post Output Validator - Layer 1 do META-AGENT System v1.0
+
+FUNÇÃO: Valida compliance do output vs especificação do agente.
+        AVISA sobre gaps mas NÃO BLOQUEIA entrega.
+
+REGRA #28: META-AGENT QUALITY AWARENESS (WARN, NOT BLOCK)
+"""
+
+import os
+import re
+import json
+from pathlib import Path
+from datetime import datetime
+from typing import List, Dict, Optional
+
+PROJECT_ROOT = Path(os.environ.get('CLAUDE_PROJECT_DIR', '.'))
+LOGS_PATH = PROJECT_ROOT / "logs"
+VALIDATION_LOG = LOGS_PATH / "output_validations.jsonl"
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# QUALITY MARKERS
+# ═══════════════════════════════════════════════════════════════════════════
+
+# Marcadores padrão para outputs visuais (usado por CHRONICLER e similares)
+VISUAL_MARKERS = [
+    {
+        "name": "ASCII Header",
+        "pattern": r"╔═+.*═+╗",
+        "weight": 10,
+        "description": "Cabeçalho com bordas duplas"
+    },
+    {
+        "name": "Progress Bar",
+        "pattern": r"[█▓░]{5,}|████+",
+        "weight": 10,
+        "description": "Barras de progresso visuais"
+    },
+    {
+        "name": "Metrics Panel",
+        "pattern": r"┌─.*(?:MÉTRICA|PAINEL|MÉTRICAS)",
+        "weight": 10,
+        "description": "Painel de métricas estruturado"
+    },
+    {
+        "name": "Changes Section",
+        "pattern": r"O QUE MUDOU|NOVIDADES|MUDANÇAS",
+        "weight": 15,
+        "description": "Seção de mudanças/novidades"
+    },
+    {
+        "name": "Personal Notes",
+        "pattern": r"NOTAS DO|OBSERVAÇÕES|— \w+$",
+        "weight": 10,
+        "description": "Notas pessoais do agente"
+    },
+    {
+        "name": "ASCII Boxes",
+        "pattern": r"[┌┐└┘├┤│─┬┴┼]{3,}",
+        "weight": 5,
+        "description": "Caixas ASCII estruturadas"
+    },
+    {
+        "name": "Explanations",
+        "pattern": r"\[[^\]]{10,}\]",
+        "weight": 5,
+        "description": "Explicações entre colchetes"
+    },
+    {
+        "name": "Section Dividers",
+        "pattern": r"[═─━]{10,}",
+        "weight": 5,
+        "description": "Divisores de seção"
+    },
+]
+
+# Marcadores para outputs analíticos
+ANALYTICAL_MARKERS = [
+    {
+        "name": "Data Points",
+        "pattern": r"\d+[%,.]?\d*",
+        "weight": 5,
+        "description": "Números e porcentagens"
+    },
+    {
+        "name": "Bullet Points",
+        "pattern": r"^[\s]*[-•*]\s",
+        "weight": 3,
+        "description": "Lista com bullets"
+    },
+    {
+        "name": "Headers",
+        "pattern": r"^#{1,3}\s",
+        "weight": 3,
+        "description": "Headers markdown"
+    },
+]
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# QUALITY SCORING
+# ═══════════════════════════════════════════════════════════════════════════
+
+def calculate_quality_score(
+    output: str,
+    markers: List[Dict] = None,
+    agent_type: str = "visual"
+) -> Dict:
+    """
+    Calcula score de qualidade do output.
+
+    Args:
+        output: Texto do output a validar
+        markers: Lista de marcadores customizados (opcional)
+        agent_type: "visual" ou "analytical" para selecionar marcadores
+
+    Returns:
+        dict com score, passing, details, missing
+    """
+    if markers is None:
+        markers = VISUAL_MARKERS if agent_type == "visual" else ANALYTICAL_MARKERS
+
+    score = 0
+    max_score = sum(m["weight"] for m in markers)
+    details = []
+    missing = []
+    found = []
+
+    for marker in markers:
+        pattern = marker["pattern"]
+        weight = marker["weight"]
+        name = marker["name"]
+
+        if re.search(pattern, output, re.IGNORECASE | re.MULTILINE):
+            score += weight
+            details.append(f"✅ {name}: +{weight}")
+            found.append(name)
+        else:
+            missing.append(name)
+            details.append(f"❌ {name}: 0")
+
+    # Normaliza para 100
+    normalized_score = int((score / max_score) * 100) if max_score > 0 else 0
+
+    return {
+        "score": normalized_score,
+        "raw_score": score,
+        "max_score": max_score,
+        "passing": normalized_score >= 70,
+        "details": details,
+        "missing": missing,
+        "found": found,
+        "markers_checked": len(markers)
+    }
+
+
+def validate_output(output: str, agent_name: str, agent_type: str = "visual") -> Dict:
+    """
+    Valida output completo. AVISA mas NÃO BLOQUEIA.
+
+    Esta é a função principal chamada após geração de output.
+    MODIFICAÇÃO CRÍTICA: action = "warn" em vez de "block"
+
+    Args:
+        output: Texto do output gerado
+        agent_name: Nome do agente que gerou
+        agent_type: Tipo do agente ("visual", "analytical")
+
+    Returns:
+        dict com resultado da validação
+    """
+    result = calculate_quality_score(output, agent_type=agent_type)
+
+    result["agent"] = agent_name
+    result["agent_type"] = agent_type
+    result["timestamp"] = datetime.now().isoformat()
+
+    if not result["passing"]:
+        # MODIFICAÇÃO: Avisa em vez de bloquear
+        result["warning"] = (
+            f"⚠️ Quality score: {result['score']}/100\n"
+            f"Missing elements: {', '.join(result['missing'])}\n"
+            f"Consider adding these elements for better quality."
+        )
+        result["action"] = "warn"  # NÃO "block"
+        result["recommendation"] = "Output delivered with quality warning"
+    else:
+        result["action"] = "pass"
+        result["recommendation"] = "Output quality acceptable"
+
+    # Log validation
+    log_validation(result)
+
+    return result
+
+
+def validate_against_spec(output: str, spec: str, agent_name: str) -> Dict:
+    """
+    Valida output contra especificação customizada.
+
+    Para casos onde MANDATORY_SECTIONS define requisitos específicos.
+    """
+    result = {
+        "agent": agent_name,
+        "timestamp": datetime.now().isoformat(),
+        "spec_based": True,
+        "requirements_met": [],
+        "requirements_missing": []
+    }
+
+    # Extrai requisitos da spec
+    requirements = extract_requirements_from_spec(spec)
+
+    score = 0
+    for req in requirements:
+        if re.search(req["pattern"], output, re.IGNORECASE | re.DOTALL):
+            result["requirements_met"].append(req["name"])
+            score += req.get("weight", 10)
+        else:
+            result["requirements_missing"].append(req["name"])
+
+    max_score = sum(r.get("weight", 10) for r in requirements)
+    result["score"] = int((score / max_score) * 100) if max_score > 0 else 100
+    result["passing"] = result["score"] >= 70
+
+    if not result["passing"]:
+        result["action"] = "warn"
+        result["warning"] = f"Score: {result['score']}. Missing: {result['requirements_missing']}"
+    else:
+        result["action"] = "pass"
+
+    return result
+
+
+def extract_requirements_from_spec(spec: str) -> List[Dict]:
+    """
+    Extrai requisitos de uma spec MANDATORY_SECTIONS.
+
+    Formato esperado na spec:
+    | Section | Required | Marker | Example |
+    """
+    requirements = []
+
+    # Tenta extrair da tabela markdown
+    table_pattern = r'\|\s*([^|]+)\s*\|\s*YES\s*\|\s*`([^`]+)`\s*\|'
+    matches = re.findall(table_pattern, spec, re.IGNORECASE)
+
+    for name, marker in matches:
+        requirements.append({
+            "name": name.strip(),
+            "pattern": re.escape(marker.strip()),
+            "weight": 10
+        })
+
+    # Se não encontrou tabela, usa marcadores padrão
+    if not requirements:
+        return [{"name": "default", "pattern": ".", "weight": 100}]
+
+    return requirements
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# LOGGING
+# ═══════════════════════════════════════════════════════════════════════════
+
+def log_validation(result: Dict):
+    """Loga resultado da validação."""
+    VALIDATION_LOG.parent.mkdir(parents=True, exist_ok=True)
+
+    entry = {
+        "timestamp": result.get("timestamp", datetime.now().isoformat()),
+        "agent": result.get("agent", "unknown"),
+        "score": result.get("score", 0),
+        "passing": result.get("passing", False),
+        "action": result.get("action", "unknown"),
+        "missing": result.get("missing", []),
+        "found": result.get("found", [])
+    }
+
+    try:
+        with open(VALIDATION_LOG, "a", encoding='utf-8') as f:
+            f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+    except Exception:
+        pass  # Falha silenciosa
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# INTEGRATION HELPERS
+# ═══════════════════════════════════════════════════════════════════════════
+
+def should_trigger_doctor(result: Dict, threshold: int = 50) -> bool:
+    """
+    Determina se deve acionar o DOCTOR (Layer 2) para propor fixes.
+
+    Threshold mais baixo (50) aciona propostas de melhoria.
+    Threshold 70 é apenas warning.
+    """
+    return result.get("score", 100) < threshold
+
+
+def format_warning_message(result: Dict) -> str:
+    """Formata mensagem de warning para exibição."""
+    if result.get("action") == "pass":
+        return ""
+
+    return f"""
+┌─────────────────────────────────────────────────────────────────────┐
+│  ⚠️ QUALITY WARNING                                                 │
+├─────────────────────────────────────────────────────────────────────┤
+│  Agent: {result.get('agent', 'unknown'):<54} │
+│  Score: {result.get('score', 0)}/100 {'(PASSING)' if result.get('passing') else '(BELOW THRESHOLD)':>43} │
+├─────────────────────────────────────────────────────────────────────┤
+│  Missing: {', '.join(result.get('missing', []))[:53]:<53} │
+└─────────────────────────────────────────────────────────────────────┘
+"""
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# CLI INTERFACE
+# ═══════════════════════════════════════════════════════════════════════════
+
+if __name__ == "__main__":
+    # Test output
+    test_output = """
+╔═══════════════════════════════════════════════════════════════════════════════╗
+║                    ALEX HORMOZI - DNA CONSOLIDADO                            ║
+╚═══════════════════════════════════════════════════════════════════════════════╝
+
+┌─ MÉTRICAS ─────────────────────────────────────────────────────────────────────┐
+│  Total elementos: 260                                                          │
+│  Progresso: ████████████████████░░░░░░░░░░░░░░░░░░░░ 50%                       │
+└────────────────────────────────────────────────────────────────────────────────┘
+
+O QUE MUDOU DESDE O ÚLTIMO LOG:
+- Adicionados 30 novos frameworks
+- Atualizado DNA-CONFIG.yaml
+
+NOTAS DO CHRONICLER:
+"O conhecimento do Hormozi está consolidando bem."
+
+— Chronicler
+"""
+
+    result = validate_output(test_output, "chronicler", "visual")
+
+    print(f"Score: {result['score']}/100")
+    print(f"Passing: {result['passing']}")
+    print(f"Action: {result['action']}")
+    print(f"\nDetails:")
+    for detail in result['details']:
+        print(f"  {detail}")
+
+    if result.get('warning'):
+        print(f"\n{result['warning']}")
+
+    print(format_warning_message(result))

package/.claude/hooks/post_tool_use.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""
+JARVIS Post Tool Use Hook
+Executado após Claude Code usar uma ferramenta de edição/escrita.
+
+Responsabilidades:
+1. Registrar arquivos modificados
+2. Detectar padrões
+3. Sugerir melhorias quando apropriado
+"""
+
+import json
+import sys
+import os
+from datetime import datetime
+from pathlib import Path
+
+def get_project_dir():
+    """Obtém o diretório do projeto."""
+    return os.environ.get('CLAUDE_PROJECT_DIR', os.getcwd())
+
+def load_actions_log():
+    """Carrega log de ações."""
+    project_dir = get_project_dir()
+    log_path = Path(project_dir) / 'logs' / 'actions.json'
+    
+    if log_path.exists():
+        with open(log_path, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    return {'actions': []}
+
+def save_actions_log(log):
+    """Salva log de ações."""
+    project_dir = get_project_dir()
+    log_path = Path(project_dir) / 'logs' / 'actions.json'
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    # Manter apenas últimas 100 ações
+    log['actions'] = log['actions'][-100:]
+    
+    with open(log_path, 'w', encoding='utf-8') as f:
+        json.dump(log, f, indent=2, ensure_ascii=False)
+
+def detect_patterns(actions):
+    """Detecta padrões nas ações recentes."""
+    if len(actions) < 3:
+        return None
+    
+    # Verificar se mesmo arquivo foi editado múltiplas vezes
+    recent = actions[-10:]
+    file_counts = {}
+    for action in recent:
+        file_path = action.get('file_path', '')
+        if file_path:
+            file_counts[file_path] = file_counts.get(file_path, 0) + 1
+    
+    # Se algum arquivo foi editado 3+ vezes
+    repeated = [f for f, c in file_counts.items() if c >= 3]
+    if repeated:
+        return {
+            'type': 'repeated_edits',
+            'files': repeated,
+            'suggestion': 'Arquivo editado múltiplas vezes. Considerar refatoração.'
+        }
+    
+    return None
+
+def main():
+    """Função principal do hook."""
+    try:
+        # Ler input do hook (stdin)
+        input_data = sys.stdin.read()
+        hook_input = json.loads(input_data) if input_data else {}
+        
+        # Extrair informações da ferramenta
+        tool_name = hook_input.get('tool_name', 'unknown')
+        tool_input = hook_input.get('tool_input', {})
+        
+        file_path = tool_input.get('file_path', '')
+        
+        # Carregar log
+        log = load_actions_log()
+        
+        # Registrar ação
+        action = {
+            'timestamp': datetime.now().isoformat(),
+            'tool': tool_name,
+            'file_path': file_path,
+            'session_id': hook_input.get('session_id', 'unknown')
+        }
+        log['actions'].append(action)
+        
+        # Salvar log
+        save_actions_log(log)
+        
+        # Detectar padrões
+        pattern = detect_patterns(log['actions'])
+        
+        # Preparar feedback
+        feedback = None
+        if pattern:
+            feedback = f"[JARVIS] Padrão detectado: {pattern['suggestion']}"
+        
+        output = {
+            'continue': True,
+            'feedback': feedback
+        }
+        
+        print(json.dumps(output))
+        
+    except Exception as e:
+        # Em caso de erro, não bloquear a operação
+        error_output = {
+            'continue': True,
+            'feedback': None
+        }
+        print(json.dumps(error_output))
+
+if __name__ == '__main__':
+    main()

package/.claude/hooks/post_write_validator.py

@@ -0,0 +1,200 @@
+#!/usr/bin/env python3
+"""
+POST-WRITE VALIDATOR HOOK
+=========================
+Valida automaticamente arquivos criados/editados.
+
+Baseado no workflow Boris Cherny: "give Claude a way to verify its work"
+
+Triggers:
+- Após Write de BATCH-*.md → Valida estrutura do batch
+- Após Write de AGENT.md → Valida template V3
+- Após Write de SOUL.md → Valida rastreabilidade
+- Após Write de DNA-CONFIG.yaml → Valida estrutura
+
+Output:
+- Se válido: exit 0 (silencioso)
+- Se inválido: print erros para Claude corrigir
+"""
+
+import sys
+import os
+import json
+import re
+from pathlib import Path
+from datetime import datetime
+
+# Paths
+PROJECT_ROOT = Path(os.environ.get('CLAUDE_PROJECT_DIR', '.'))
+LOGS_PATH = PROJECT_ROOT / 'logs' / 'validation'
+LOGS_PATH.mkdir(parents=True, exist_ok=True)
+
+def log_validation(file_path: str, file_type: str, is_valid: bool, errors: list):
+    """Log validation result"""
+    log_file = LOGS_PATH / 'validation.jsonl'
+    entry = {
+        'timestamp': datetime.now().isoformat(),
+        'file': file_path,
+        'type': file_type,
+        'valid': is_valid,
+        'errors': errors
+    }
+    with open(log_file, 'a') as f:
+        f.write(json.dumps(entry) + '\n')
+
+def validate_batch(content: str, file_path: str) -> tuple[bool, list]:
+    """Validate BATCH-*.md structure"""
+    errors = []
+
+    # Required sections
+    required_sections = [
+        ('ASCII ART HEADER', r'[╔═╗║╚]'),
+        ('CONTEXTO DA MISSÃO', r'CONTEXTO DA MISS[ÃA]O|MISSION CONTEXT'),
+        ('BATCH SUMMARY', r'BATCH SUMMARY|RESUMO DO BATCH'),
+        ('ARQUIVOS PROCESSADOS', r'ARQUIVOS PROCESSADOS|FILES PROCESSED'),
+        ('DESTINO DO CONHECIMENTO', r'DESTINO DO CONHECIMENTO|KNOWLEDGE DESTINATION'),
+        ('KEY FRAMEWORKS', r'KEY FRAMEWORKS|FRAMEWORKS'),
+    ]
+
+    for section_name, pattern in required_sections:
+        if not re.search(pattern, content, re.IGNORECASE):
+            errors.append(f"Missing section: {section_name}")
+
+    # Check for cascading section (REGRA #22)
+    if 'Cascateamento Executado' not in content and 'CASCATEAMENTO' not in content.upper():
+        errors.append("Missing section: Cascateamento Executado (REGRA #22)")
+
+    # Check for DNA layers
+    dna_layers = ['FILOSOFIA', 'MODELO-MENTAL', 'HEURISTICA', 'FRAMEWORK', 'METODOLOGIA']
+    found_layers = sum(1 for layer in dna_layers if layer in content.upper())
+    if found_layers < 3:
+        errors.append(f"Only {found_layers}/5 DNA layers found. Expected at least 3.")
+
+    is_valid = len(errors) == 0
+    log_validation(file_path, 'BATCH', is_valid, errors)
+    return is_valid, errors
+
+def validate_agent(content: str, file_path: str) -> tuple[bool, list]:
+    """Validate AGENT.md template V3 structure"""
+    errors = []
+
+    # Required parts from Template V3
+    required_parts = [
+        ('PARTE 0: ÍNDICE', r'PARTE 0|ÍNDICE|INDEX'),
+        ('PARTE 1: COMPOSIÇÃO', r'PARTE 1|COMPOSI[ÇC][ÃA]O'),
+        ('PARTE 3: MAPA NEURAL', r'PARTE 3|MAPA NEURAL|DNA'),
+        ('PARTE 5: SISTEMA DE VOZ', r'PARTE 5|VOZ|VOICE'),
+    ]
+
+    for part_name, pattern in required_parts:
+        if not re.search(pattern, content, re.IGNORECASE):
+            errors.append(f"Missing: {part_name}")
+
+    # Check for ASCII header
+    if not re.search(r'[╔═╗║╚]', content):
+        errors.append("Missing ASCII art header")
+
+    # Check for version
+    if not re.search(r'[Vv]ers[ãa]o|Version', content):
+        errors.append("Missing version declaration")
+
+    # Check for sources/fontes
+    if not re.search(r'[Ff]ontes?|[Ss]ources?', content):
+        errors.append("Missing source attribution")
+
+    is_valid = len(errors) == 0
+    log_validation(file_path, 'AGENT', is_valid, errors)
+    return is_valid, errors
+
+def validate_soul(content: str, file_path: str) -> tuple[bool, list]:
+    """Validate SOUL.md rastreabilidade"""
+    errors = []
+
+    # Check for source citations
+    citation_patterns = [
+        r'\^\[FONTE:',
+        r'\^\[chunk_id',
+        r'\^\[insight_id',
+        r'\^\[RAIZ:',
+        r'\[FONTE:',
+    ]
+
+    has_citations = any(re.search(p, content) for p in citation_patterns)
+    if not has_citations:
+        errors.append("No traceable citations found (REGRA #24 requires ^[FONTE:] or similar)")
+
+    # Check for DNA layers
+    if not re.search(r'FILOSOFIA|MODELO.MENTAL|HEURISTICA|FRAMEWORK|METODOLOGIA', content, re.IGNORECASE):
+        errors.append("No DNA layers referenced")
+
+    is_valid = len(errors) == 0
+    log_validation(file_path, 'SOUL', is_valid, errors)
+    return is_valid, errors
+
+def validate_dna_config(content: str, file_path: str) -> tuple[bool, list]:
+    """Validate DNA-CONFIG.yaml structure"""
+    errors = []
+
+    # Required fields
+    required_fields = ['name', 'type', 'version']
+    for field in required_fields:
+        if f'{field}:' not in content.lower():
+            errors.append(f"Missing required field: {field}")
+
+    # Check for layers
+    layers = ['filosofias', 'modelos_mentais', 'heuristicas', 'frameworks', 'metodologias']
+    found_layers = sum(1 for layer in layers if layer in content.lower())
+    if found_layers < 3:
+        errors.append(f"Only {found_layers}/5 DNA layers defined")
+
+    is_valid = len(errors) == 0
+    log_validation(file_path, 'DNA_CONFIG', is_valid, errors)
+    return is_valid, errors
+
+def main():
+    """Main validation dispatcher"""
+    if len(sys.argv) < 2:
+        sys.exit(0)
+
+    file_path = sys.argv[1]
+
+    # Skip if file doesn't exist or is not relevant
+    if not os.path.exists(file_path):
+        sys.exit(0)
+
+    filename = os.path.basename(file_path).upper()
+
+    # Determine file type and validate
+    try:
+        with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+            content = f.read()
+    except Exception:
+        sys.exit(0)
+
+    is_valid = True
+    errors = []
+
+    if 'BATCH-' in filename and filename.endswith('.MD'):
+        is_valid, errors = validate_batch(content, file_path)
+    elif filename == 'AGENT.MD':
+        is_valid, errors = validate_agent(content, file_path)
+    elif filename == 'SOUL.MD':
+        is_valid, errors = validate_soul(content, file_path)
+    elif 'DNA-CONFIG' in filename and filename.endswith('.YAML'):
+        is_valid, errors = validate_dna_config(content, file_path)
+    else:
+        # Not a file we validate
+        sys.exit(0)
+
+    # Output for Claude to see
+    if not is_valid:
+        print(f"\n⚠️ VALIDATION FAILED for {os.path.basename(file_path)}:")
+        for error in errors:
+            print(f"  ❌ {error}")
+        print("\nPlease fix these issues before proceeding.\n")
+        # Exit 0 anyway to not block, but Claude sees the output
+
+    sys.exit(0)
+
+if __name__ == '__main__':
+    main()