# Baixar a imagem
docker pull empresa/gerenciador-agentes-ia:latest

# Executar o contêiner
docker run -d \
  --name gerenciador-agentes \
  -p 8000:8000 \
  -v /caminho/para/config:/app/config \
  -v /caminho/para/data:/app/data \
  empresa/gerenciador-agentes-ia:latest

# Verificar logs
docker logs gerenciador-agentes
                        

# Iniciar com arquivo de configuração
gerenciador-agentes-ia start --config /caminho/para/config.yaml

# Iniciar com variáveis de ambiente
export GERENCIADOR_SISTEMA_NOME="Meu Sistema de Agentes"
export GERENCIADOR_API_PORTA=9000
gerenciador-agentes-ia start

# Iniciar em modo de desenvolvimento
gerenciador-agentes-ia start --dev

# Iniciar com configurações específicas
gerenciador-agentes-ia start --host 0.0.0.0 --porta 8080 --workers 8
                        

import requests
import json

# Configuração base
API_URL = "http://localhost:8000/api"
USERNAME = "admin"
PASSWORD = "senha_segura"

# Obter token de autenticação
def get_token():
    response = requests.post(
        f"{API_URL}/auth/token",
        json={"username": USERNAME, "password": PASSWORD}
    )
    data = response.json()
    return data["access_token"]

# Configurar cabeçalhos com token
token = get_token()
headers = {
    "Authorization": f"Bearer {token}",
    "Content-Type": "application/json"
}

# Listar agentes disponíveis
def list_agents():
    response = requests.get(f"{API_URL}/agents", headers=headers)
    return response.json()

# Enviar mensagem para um agente
def send_message_to_agent(agent_id, message):
    response = requests.post(
        f"{API_URL}/agents/{agent_id}/message",
        headers=headers,
        json={"message": message}
    )
    return response.json()

# Criar um novo squad
def create_squad(name, description, agent_ids):
    response = requests.post(
        f"{API_URL}/squads",
        headers=headers,
        json={
            "name": name,
            "description": description,
            "agent_ids": agent_ids
        }
    )
    return response.json()

# Enviar tarefa para um squad
def send_task_to_squad(squad_id, task):
    response = requests.post(
        f"{API_URL}/squads/{squad_id}/task",
        headers=headers,
        json={"task": task}
    )
    return response.json()

# Exemplo de uso
if __name__ == "__main__":
    # Listar agentes
    agents = list_agents()
    print(f"Agentes disponíveis: {json.dumps(agents, indent=2)}")
    
    # Enviar mensagem para o agente de marketing
    marketing_agent_id = "agent_marketing_1"
    response = send_message_to_agent(
        marketing_agent_id,
        "Analise os resultados da nossa campanha de email marketing do último trimestre."
    )
    print(f"Resposta do agente: {json.dumps(response, indent=2)}")
    
    # Criar um squad para análise de mercado
    squad = create_squad(
        name="Squad de Análise de Mercado",
        description="Squad para análise completa de mercado e concorrência",
        agent_ids=["agent_marketing_1", "agent_financial_1", "agent_sales_1"]
    )
    print(f"Squad criado: {json.dumps(squad, indent=2)}")
    
    # Enviar tarefa para o squad
    task_response = send_task_to_squad(
        squad["id"],
        "Realize uma análise completa do mercado de software de gestão empresarial, incluindo análise de concorrentes, tendências e oportunidades."
    )
    print(f"Resposta da tarefa: {json.dumps(task_response, indent=2)}")
                        

"""
Você é um especialista financeiro com vasta experiência em análise financeira, planejamento orçamentário,
previsões financeiras e análise de investimentos. Seu objetivo é fornecer análises precisas, recomendações
baseadas em dados e orientações claras sobre questões financeiras.

Ao responder a consultas, você deve:

1. ANÁLISE:
   - Analisar os dados financeiros fornecidos de forma objetiva e imparcial
   - Identificar tendências, padrões e anomalias relevantes
   - Considerar o contexto específico da empresa ou situação

2. RECOMENDAÇÕES:
   - Fornecer recomendações práticas e acionáveis
   - Basear suas recomendações em princípios financeiros sólidos e melhores práticas
   - Apresentar múltiplas opções quando apropriado, com prós e contras

3. COMUNICAÇÃO:
   - Usar linguagem clara e precisa, evitando jargão desnecessário
   - Explicar conceitos financeiros complexos de forma acessível
   - Estruturar suas respostas de forma lógica e organizada

4. LIMITAÇÕES:
   - Reconhecer quando informações adicionais são necessárias para uma análise completa
   - Não fazer previsões específicas sobre mercados ou investimentos sem ressalvas apropriadas
   - Evitar conselhos que possam ser interpretados como consultoria financeira regulamentada

Ao analisar demonstrações financeiras, você deve considerar:
- Balanço patrimonial: liquidez, alavancagem, estrutura de capital
- Demonstração de resultados: margens, crescimento, eficiência operacional
- Fluxo de caixa: geração de caixa operacional, investimentos, financiamentos
- Indicadores-chave: ROI, ROE, EBITDA, índices de liquidez, ciclo operacional

Ao fazer projeções financeiras, você deve:
- Basear-se em premissas claras e justificáveis
- Considerar múltiplos cenários (otimista, realista, pessimista)
- Incluir análises de sensibilidade para variáveis críticas
- Apresentar os resultados com intervalos de confiança apropriados

Formato de resposta preferido:
1. Resumo executivo (2-3 frases)
2. Análise detalhada (estruturada por tópicos relevantes)
3. Recomendações específicas
4. Próximos passos sugeridos
5. Considerações adicionais ou limitações da análise
"""
                        

from gerenciador_agentes_ia.core import SquadManager

# Inicializar o gerenciador de squads
squad_manager = SquadManager()

# Obter um squad existente
market_analysis_squad = squad_manager.get_squad("squad_market_analysis")

# Enviar uma tarefa para o squad
task_result = squad_manager.execute_task(
    squad_id="squad_market_analysis",
    task="Realize uma análise completa do mercado de software de gestão empresarial, incluindo análise de concorrentes, tendências e oportunidades.",
    context={
        "target_market": "Pequenas e médias empresas",
        "geographic_focus": "Brasil",
        "industry_sectors": ["Varejo", "Serviços", "Manufatura"],
        "time_horizon": "12 meses"
    },
    requester="user@company.com"
)

# Verificar o status da tarefa
task_id = task_result["task_id"]
task_status = squad_manager.get_task_status(task_id)

print(f"Status da tarefa: {task_status['status']}")
print(f"Progresso: {task_status['progress']}%")

# Se a tarefa estiver concluída, obter o resultado
if task_status["status"] == "completed":
    task_result = squad_manager.get_task_result(task_id)
    print(f"Resultado da tarefa: {task_result['summary']}")
    
    # Acessar resultados detalhados por agente
    for agent_result in task_result["agent_results"]:
        print(f"Resultado do agente {agent_result['agent_id']}:")
        print(agent_result["content"])
                        

from gerenciador_agentes_ia.communication import MessageFormatter
from gerenciador_agentes_ia.chat_integration import SlackConnector

# Criar um formatador de mensagens personalizado para o Slack
class CustomSlackFormatter(MessageFormatter):
    def format_agent_response(self, agent_id, response, context=None):
        """
        Formata a resposta de um agente para o Slack.
        
        Args:
            agent_id (str): ID do agente
            response (str): Resposta do agente
            context (dict, optional): Contexto adicional
            
        Returns:
            dict: Mensagem formatada para o Slack
        """
        # Obter informações do agente
        agent_info = self.agent_manager.get_agent(agent_id)
        
        # Criar blocos para a mensagem
        blocks = [
            {
                "type": "header",
                "text": {
                    "type": "plain_text",
                    "text": f"Resposta de {agent_info.name}",
                    "emoji": True
                }
            },
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": response
                }
            },
            {
                "type": "context",
                "elements": [
                    {
                        "type": "mrkdwn",
                        "text": f"*Especialidade:* {agent_info.specialty} | *Confiança:* Alta"
                    }
                ]
            },
            {
                "type": "actions",
                "elements": [
                    {
                        "type": "button",
                        "text": {
                            "type": "plain_text",
                            "text": "👍 Útil",
                            "emoji": True
                        },
                        "value": f"feedback_positive_{agent_id}"
                    },
                    {
                        "type": "button",
                        "text": {
                            "type": "plain_text",
                            "text": "👎 Não útil",
                            "emoji": True
                        },
                        "value": f"feedback_negative_{agent_id}"
                    },
                    {
                        "type": "button",
                        "text": {
                            "type": "plain_text",
                            "text": "🔄 Reformular",
                            "emoji": True
                        },
                        "value": f"reformulate_{agent_id}"
                    }
                ]
            }
        ]
        
        return {
            "blocks": blocks,
            "text": f"Resposta de {agent_info.name}: {response[:100]}..."
        }
    
    def format_approval_request(self, request_id, task_description, agent_id):
        """
        Formata uma solicitação de aprovação para o Slack.
        
        Args:
            request_id (str): ID da solicitação
            task_description (str): Descrição da tarefa
            agent_id (str): ID do agente
            
        Returns:
            dict: Mensagem formatada para o Slack
        """
        # Obter informações do agente
        agent_info = self.agent_manager.get_agent(agent_id)
        
        # Criar blocos para a mensagem
        blocks = [
            {
                "type": "header",
                "text": {
                    "type": "plain_text",
                    "text": "Solicitação de Aprovação",
                    "emoji": True
                }
            },
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": f"O agente *{agent_info.name}* gostaria de executar a seguinte tarefa:"
                }
            },
            {
                "type": "section",
                "text": {
                    "type": "mrkdwn",
                    "text": f"```{task_description}```"
                }
            },
            {
                "type": "actions",
                "elements": [
                    {
                        "type": "button",
                        "text": {
                            "type": "plain_text",
                            "text": "✅ Aprovar",
                            "emoji": True
                        },
                        "style": "primary",
                        "value": f"approve_{request_id}"
                    },
                    {
                        "type": "button",
                        "text": {
                            "type": "plain_text",
                            "text": "❌ Rejeitar",
                            "emoji": True
                        },
                        "style": "danger",
                        "value": f"reject_{request_id}"
                    },
                    {
                        "type": "button",
                        "text": {
                            "type": "plain_text",
                            "text": "❓ Mais informações",
                            "emoji": True
                        },
                        "value": f"more_info_{request_id}"
                    }
                ]
            }
        ]
        
        return {
            "blocks": blocks,
            "text": f"Solicitação de aprovação para tarefa: {task_description[:100]}..."
        }

# Registrar o formatador personalizado
slack_connector = SlackConnector(config["integracao"]["slack"])
slack_connector.set_message_formatter(CustomSlackFormatter())