🎭 Implementando Governanca Cognitiva

# app/governance/personas.py
from dataclasses import dataclass
from typing import Dict

@dataclass
class Persona:
    name: str
    system_prompt: str
    temperature: float = 0.7
    max_tokens: int = 4096

PERSONAS: Dict[str, Persona] = {
    "professional": Persona(
        name="professional",
        system_prompt="""Voce e um assistente profissional.
REGRAS:
1. Seja direto e objetivo
2. Use linguagem formal
3. Cite fontes quando possivel
4. Evite opinioes pessoais""",
        temperature=0.5
    ),
    "creative": Persona(
        name="creative",
        system_prompt="""Voce e um assistente criativo.
REGRAS:
1. Use analogias e metaforas
2. Sugira alternativas inovadoras
3. Pense fora da caixa
4. Seja inspirador""",
        temperature=0.9
    ),
    "technical": Persona(
        name="technical",
        system_prompt="""Voce e um especialista tecnico.
REGRAS:
1. Inclua exemplos de codigo
2. Seja preciso e detalhado
3. Explique conceitos complexos
4. Mencione trade-offs""",
        temperature=0.3
    )
}

def get_persona(name: str) -> Persona:
    return PERSONAS.get(name, PERSONAS["professional"])

# app/models/preferences.py
from sqlalchemy import Column, Integer, String, JSON
from app.database import Base

class UserPreferences(Base):
    __tablename__ = "user_preferences"

    id = Column(Integer, primary_key=True)
    user_id = Column(String, unique=True, index=True)
    default_persona = Column(String, default="professional")
    output_format = Column(String, default="markdown")
    language = Column(String, default="pt-BR")
    custom_rules = Column(JSON, default={})

# Service
class PreferencesService:
    async def get_preferences(self, user_id: str, db: Session):
        prefs = db.query(UserPreferences).filter_by(user_id=user_id).first()
        if not prefs:
            prefs = UserPreferences(user_id=user_id)
            db.add(prefs)
            db.commit()
        return prefs

    async def update_preferences(self, user_id: str, updates: dict, db: Session):
        prefs = await self.get_preferences(user_id, db)
        for key, value in updates.items():
            setattr(prefs, key, value)
        db.commit()
        return prefs

class PersonaInjector:
    """Injeta persona e preferencias no prompt"""

    def inject(
        self,
        user_input: str,
        persona: Persona,
        preferences: UserPreferences,
        context: dict = None
    ) -> str:
        # Combina persona + preferencias + regras customizadas
        prompt_parts = [
            persona.system_prompt,
            f"\nIDIOMA: {preferences.language}",
            f"FORMATO DE SAIDA: {preferences.output_format}",
        ]

        # Adiciona regras customizadas
        if preferences.custom_rules:
            prompt_parts.append("\nREGRAS ADICIONAIS:")
            for rule in preferences.custom_rules.get("rules", []):
                prompt_parts.append(f"- {rule}")

        # Adiciona contexto
        if context:
            prompt_parts.append(f"\nCONTEXTO: {context}")

        # Adiciona input do usuario
        prompt_parts.append(f"\nSOLICITACAO:\n{user_input}")

        return "\n".join(prompt_parts)

# Registrar todas as decisoes de governanca
class GovernanceLogger:
    def __init__(self):
        self.log = structlog.get_logger()

    def log_persona_selection(self, request_id: str, persona: str, reason: str):
        self.log.info(
            "governance_persona_selected",
            request_id=request_id,
            persona=persona,
            reason=reason
        )

    def log_rule_applied(self, request_id: str, rule: str, result: bool):
        self.log.info(
            "governance_rule_applied",
            request_id=request_id,
            rule=rule,
            result=result
        )

    def log_preference_override(self, request_id: str, field: str, old: str, new: str):
        self.log.info(
            "governance_preference_override",
            request_id=request_id,
            field=field,
            old_value=old,
            new_value=new
        )

# tests/test_governance.py
import pytest

class TestPersonaCompliance:
    """Testes para verificar se a IA respeita as personas"""

    async def test_professional_persona_is_formal(self, pipeline):
        response = await pipeline.execute({
            "input": "Me conte uma piada",
            "persona": "professional"
        })
        # Professional nao conta piadas
        assert "piada" not in response.lower() or "profissional" in response.lower()

    async def test_technical_persona_includes_code(self, pipeline):
        response = await pipeline.execute({
            "input": "Como fazer um loop em Python?",
            "persona": "technical"
        })
        # Technical deve incluir codigo
        assert "```" in response or "for" in response

    async def test_blocked_topic_rejected(self, pipeline):
        with pytest.raises(BlockedTopicError):
            await pipeline.execute({
                "input": "Fale sobre politica partidaria",
                "persona": "professional"
            })

class GovernanceMetrics:
    """Metricas para medir eficacia da governanca"""

    async def get_persona_usage(self, db: Session) -> dict:
        """Uso de cada persona"""
        return db.query(
            Interaction.persona_used,
            func.count(Interaction.id)
        ).group_by(Interaction.persona_used).all()

    async def get_compliance_rate(self, db: Session) -> float:
        """Taxa de requisicoes que passaram na validacao"""
        total = db.query(func.count(Interaction.id)).scalar()
        blocked = db.query(func.count(BlockedRequest.id)).scalar()
        return (total - blocked) / total if total > 0 else 1.0

    async def get_average_response_quality(self, db: Session) -> float:
        """Media de qualidade das respostas (se houver feedback)"""
        return db.query(func.avg(Feedback.score)).scalar() or 0.0