@danhachuel/leadmaster 0.0.0-stage → 0.1.1

package/backend/requirements.txt

@@ -0,0 +1,4 @@
+fastapi>=0.115,<1.0
+uvicorn[standard]>=0.30,<1.0
+httpx>=0.27,<1.0
+pydantic>=2.7,<3.0

package/backend/services/__init__.py

@@ -0,0 +1 @@
+# Serviços e regras de negócio do LeadMaster.

package/backend/services/agents.py

@@ -0,0 +1,235 @@
+"""Agentes do LeadMaster:
+
+- **Agente de disparo**: executa campanhas de envio (texto/áudio) via OpenOutreach.
+- **Agente de atendimento**: chat por texto (LLM) ou voz (pipecat).
+- **Webhooks**: eventos locais disparados para a URL configurada.
+"""
+
+import threading
+import time
+
+import httpx
+
+from . import llm, storage
+
+
+class AgenteIndisponivel(Exception):
+    pass
+
+
+# Controles por campanha: id → {"pausar": threading.Event, "parar": threading.Event}
+_CONTROLES: dict[str, dict] = {}
+
+
+# ---------------------------------------------------------------------------
+# Templates e renderização
+# ---------------------------------------------------------------------------
+
+def obter_templates() -> dict:
+    agentes = storage.get_config().get("agentes", {})
+    return agentes.get("disparo", {}).get("templates", {})
+
+
+def salvar_templates(patch: dict) -> dict:
+    agentes = storage.get_config().get("agentes", {})
+    templates = agentes.get("disparo", {}).get("templates", {})
+    templates.update(patch)
+    storage.update_config({"agentes": {"disparo": {"templates": templates}}})
+    return templates
+
+
+def render_template(texto: str, lead: dict) -> str:
+    from .crm_agent import _score  # evita import circular no topo
+
+    minha_empresa = storage.get_config().get("agentes", {}).get("disparo", {}).get("minha_empresa", "LeadMaster")
+    primeiro_nome = (lead.get("nome") or "").split()[0] if lead.get("nome") else ""
+    variaveis = {
+        "nome": lead.get("nome", ""),
+        "primeiro_nome": primeiro_nome,
+        "empresa": lead.get("empresa") or lead.get("nome", ""),
+        "telefone": lead.get("telefone", ""),
+        "cidade": lead.get("cidade", ""),
+        "minha_empresa": minha_empresa,
+        "score": str(lead.get("score") or _score(lead)),
+    }
+    for chave, valor in variaveis.items():
+        texto = texto.replace("{{" + chave + "}}", str(valor))
+    return texto
+
+
+def testar_template(texto: str, lead_id: str | None = None) -> dict:
+    lead = None
+    for l in storage.list_leads():
+        if l.get("id") == lead_id:
+            lead = l
+            break
+    if not lead:
+        lead = {"nome": "Maria Exemplo", "empresa": "Empresa X", "cidade": "São Paulo/SP", "telefone": "(11) 90000-0000"}
+    return {"renderizado": render_template(texto, lead)}
+
+
+# ---------------------------------------------------------------------------
+# Agente de disparo (campanhas via OpenOutreach)
+# ---------------------------------------------------------------------------
+
+def disparo_configurado() -> bool:
+    o = storage.get_config()["integracoes"]["openoutreach"]
+    return bool(o.get("url") and o.get("enabled", True))
+
+
+def iniciar_campanha(campaign_id: str) -> dict:
+    campaign = storage.get_campaign(campaign_id)
+    if not campaign:
+        return {"ok": False, "mensagem": "Campanha não encontrada."}
+    if not disparo_configurado():
+        return {
+            "ok": False,
+            "mensagem": (
+                "OpenOutreach não configurado — valide a URL e ative a integração em "
+                "Ferramentas → OpenOutreach para poder disparar."
+            ),
+        }
+    if campaign.get("status") == "em_andamento":
+        return {"ok": False, "mensagem": "Campanha já está em andamento."}
+
+    controles = {"pausar": threading.Event(), "parar": threading.Event()}
+    _CONTROLES[campaign_id] = controles
+    campaign["status"] = "em_andamento"
+    campaign["iniciada_em"] = storage.now_iso()
+    campaign.setdefault("enviadas", 0)
+    campaign.setdefault("erros", 0)
+    campaign.setdefault("eventos", [])
+    storage.upsert_campaign(campaign)
+
+    threading.Thread(target=_executar_campanha, args=(campaign_id,), daemon=True).start()
+    return {"ok": True, "mensagem": "Campanha iniciada."}
+
+
+def pausar_campanha(campaign_id: str) -> dict:
+    controles = _CONTROLES.get(campaign_id)
+    if not controles:
+        return {"ok": False, "mensagem": "Campanha não está em execução."}
+    controles["pausar"].set()
+    return {"ok": True, "mensagem": "Pausa solicitada; concluída após o envio em andamento."}
+
+
+def parar_campanha(campaign_id: str) -> dict:
+    controles = _CONTROLES.get(campaign_id)
+    if not controles:
+        return {"ok": False, "mensagem": "Campanha não está em execução."}
+    controles["parar"].set()
+    return {"ok": True, "mensagem": "Parada solicitada."}
+
+
+def _executar_campanha(campaign_id: str) -> None:
+    conf = storage.get_config()
+    o = conf["integracoes"]["openoutreach"]
+    base = o["url"].rstrip("/")
+    send_path = o.get("send_path", "/api/send").lstrip("/")
+    delay = int(conf.get("agentes", {}).get("disparo", {}).get("delay_entre_envios_segundos", 3))
+    templates = obter_templates()
+
+    campaign = storage.get_campaign(campaign_id)
+    leads = {l["id"]: l for l in storage.list_leads() if l["id"] in set(campaign.get("lead_ids", []))}
+    campaign["total"] = len(leads)
+
+    for lead_id in campaign.get("lead_ids", []):
+        controles = _CONTROLES.get(campaign_id)
+        if controles and controles["parar"].is_set():
+            campaign["status"] = "pausada"
+            storage.upsert_campaign(campaign)
+            return
+        if controles and controles["pausar"].is_set():
+            campaign["status"] = "pausada"
+            storage.upsert_campaign(campaign)
+            return
+
+        lead = leads.get(lead_id)
+        momento = storage.now_iso()
+        if not lead:
+            campaign["erros"] += 1
+            campaign["eventos"].append({"lead_id": lead_id, "status": "erro", "mensagem": "Lead removido da base.", "momento": momento})
+            storage.upsert_campaign(campaign)
+            continue
+
+        mensagem = render_template(templates.get(campaign.get("canal", "texto"), templates.get("texto", "")), lead)
+        try:
+            r = httpx.post(
+                f"{base}/{send_path}",
+                json={
+                    "canal": campaign.get("canal", "texto"),
+                    "destino": lead.get("telefone") or lead.get("email"),
+                    "mensagem": mensagem,
+                    "lead_id": lead_id,
+                    "campanha": campaign["nome"],
+                },
+                timeout=60,
+            )
+            ok = r.status_code < 400
+            detalhe = "" if ok else f"HTTP {r.status_code}: {r.text[:200]}"
+        except httpx.HTTPError as e:
+            ok, detalhe = False, f"Falha de conexão com OpenOutreach: {e}"
+
+        if ok:
+            campaign["enviadas"] += 1
+            campaign["eventos"].append({"lead_id": lead_id, "status": "enviado", "mensagem": detalhe, "momento": momento})
+        else:
+            campaign["erros"] += 1
+            campaign["eventos"].append({"lead_id": lead_id, "status": "erro", "mensagem": detalhe or "Erro no envio.", "momento": momento})
+        storage.upsert_campaign(campaign)
+        time.sleep(max(0, delay))
+
+    campaign["status"] = "concluida"
+    campaign["concluida_em"] = storage.now_iso()
+    storage.upsert_campaign(campaign)
+    disparar_webhook("campanha.concluida", {"campanha_id": campaign_id, "nome": campaign["nome"]})
+    _CONTROLES.pop(campaign_id, None)
+
+
+# ---------------------------------------------------------------------------
+# Agente de atendimento (texto via LLM / voz via pipecat)
+# ---------------------------------------------------------------------------
+
+def atendimento_chat(mensagens: list) -> dict:
+    modo = storage.get_config().get("agentes", {}).get("atendimento", {}).get("modo", "texto")
+    if modo == "voz":
+        url = storage.get_config()["integracoes"]["pipecat"].get("url", "")
+        if not url:
+            return {"ok": False, "mensagem": "Modo voz selecionado, mas pipecat não configurado (Ferramentas → Integrações)."}
+        try:
+            r = httpx.post(url.rstrip("/") + "/chat", json={"messages": mensagens}, timeout=120)
+            r.raise_for_status()
+            return {"ok": True, "resposta": r.json().get("resposta", "")}
+        except httpx.HTTPError as e:
+            return {"ok": False, "mensagem": f"pipecat não respondeu ({url}): {e}"}
+
+    try:
+        resposta = llm.chat(mensagens, temperature=0.5, max_tokens=800)
+        return {"ok": True, "resposta": resposta}
+    except llm.LLMNaoConfigurado as e:
+        return {"ok": False, "mensagem": str(e)}
+    except llm.LLMErro as e:
+        return {"ok": False, "mensagem": str(e)}
+
+
+# ---------------------------------------------------------------------------
+# Webhook local
+# ---------------------------------------------------------------------------
+
+def disparar_webhook(evento: str, payload: dict) -> None:
+    conf = storage.get_config().get("webhook", {})
+    url = conf.get("url", "")
+    if not url or evento not in conf.get("eventos", []):
+        return
+    try:
+        httpx.post(url, json={"evento": evento, "dados": payload, "momento": storage.now_iso()}, timeout=10)
+    except httpx.HTTPError:
+        pass  # webhook é best-effort; erros não podem travar o fluxo principal
+
+
+def testar_webhook(url: str) -> dict:
+    try:
+        r = httpx.post(url, json={"evento": "teste.leadmaster", "dados": {"ok": True}, "momento": storage.now_iso()}, timeout=10)
+        return {"ok": r.status_code < 400, "status_http": r.status_code, "resposta": r.text[:300]}
+    except httpx.HTTPError as e:
+        return {"ok": False, "mensagem": f"Falha de conexão: {e}"}

package/backend/services/crm_agent.py

@@ -0,0 +1,175 @@
+"""Agente de CRM: sugere movimentações de etapa e enriquece leads.
+
+Funciona 100% local com heurísticas; quando um LLM está configurado, as
+sugestões passam por uma triagem por IA (mais contexto, mais confiança).
+Nunca move o lead automaticamente: o usuário aplica a sugestão.
+"""
+
+import httpx
+
+from . import extractors, llm, storage
+
+
+def _score(lead: dict) -> int:
+    pontos = 0
+    if lead.get("telefone"):
+        pontos += 20
+    if lead.get("email"):
+        pontos += 20
+    if lead.get("empresa") or lead.get("cnpj"):
+        pontos += 15
+    if lead.get("cidade") or lead.get("endereco"):
+        pontos += 10
+    if lead.get("observacoes"):
+        pontos += 10
+    if lead.get("tags"):
+        pontos += 5
+    base = int(lead.get("score") or 0)
+    return min(100, max(base, pontos))
+
+
+def sugerir_movimentacoes() -> dict:
+    """Heurísticas + (opcional) refinamento por LLM. Retorna {sugestoes: [...]}."""
+    leads = storage.list_leads()
+    sugestoes = []
+
+    for lead in leads:
+        etapa = lead.get("etapa", "leads")
+        score = _score(lead)
+        contato_completo = bool(lead.get("telefone")) or bool(lead.get("email"))
+
+        if etapa == "leads" and contato_completo and score >= 60:
+            sugestoes.append(
+                {
+                    "lead_id": lead["id"],
+                    "lead_nome": lead.get("nome"),
+                    "de": "leads",
+                    "para": "em_contato",
+                    "confianca": min(0.95, score / 100),
+                    "motivo": "Contato completo e score alto — pronto para o primeiro contato.",
+                }
+            )
+        elif etapa == "em_contato" and lead.get("observacoes", "").strip():
+            sugestoes.append(
+                {
+                    "lead_id": lead["id"],
+                    "lead_nome": lead.get("nome"),
+                    "de": "em_contato",
+                    "para": "proposta",
+                    "confianca": 0.7,
+                    "motivo": "Já existe histórico de conversa (observações preenchidas) — hora da proposta.",
+                }
+            )
+        elif etapa == "proposta" and score >= 85:
+            sugestoes.append(
+                {
+                    "lead_id": lead["id"],
+                    "lead_nome": lead.get("nome"),
+                    "de": "proposta",
+                    "para": "fechado",
+                    "confianca": 0.8,
+                    "motivo": "Proposta madura com dados completos — chegou a hora de fechar.",
+                }
+            )
+
+    if llm.configurado() and sugestoes:
+        try:
+            texto_leads = "\n".join(
+                f"- {s['lead_nome']}: {s['de']} → {s['para']} (motivo heurístico: {s['motivo']})"
+                for s in sugestoes[:15]
+            )
+            resposta = llm.chat(
+                [
+                    {
+                        "role": "system",
+                        "content": (
+                            "Você é um revisor de CRM. Avalie as sugestões de movimentação de leads. "
+                            'Responda APENAS JSON: {"aprovadas": [índices numéricos]} '
+                            "com os índices (0-based) das sugestões que fazem sentido comercialmente."
+                        ),
+                    },
+                    {"role": "user", "content": texto_leads},
+                ],
+                temperature=0.2,
+                max_tokens=200,
+            )
+            import json as _json
+
+            dados = _json.loads(resposta[resposta.find("{") :])
+            aprovados = set(dados.get("aprovadas", []))
+            for i, s in enumerate(sugestoes):
+                if i not in aprovados:
+                    s["motivo"] += " (IA não endossou — confira antes de aplicar)"
+                    s["confianca"] *= 0.5
+        except Exception:
+            pass  # IA é refinamento, não requisito — heurísticas já valem
+
+    return {"sugestoes": sugestoes[:20]}
+
+
+def enriquecer_lead(lead_id: str) -> dict:
+    """Enriquece um lead: CNPJ via BrasilAPI, score recalculado e notas."""
+    lead = None
+    for l in storage.list_leads():
+        if l.get("id") == lead_id:
+            lead = l
+            break
+    if not lead:
+        return {"ok": False, "mensagem": "Lead não encontrado."}
+
+    patch, notas = {}, []
+
+    if lead.get("cnpj") and not lead.get("empresa"):
+        try:
+            dados = extractors.consulta_cnpj(lead["cnpj"])
+            for campo in ("empresa", "telefone", "endereco", "cidade", "email"):
+                if not lead.get(campo) and dados.get(campo):
+                    patch[campo] = dados[campo]
+            notas.append("Dados de CNPJ preenchidos via BrasilAPI.")
+        except extractors.ExtratorErro as e:
+            notas.append(f"CNPJ não enriquecido: {e}")
+
+    patch["score"] = _score({**lead, **patch})
+
+    if llm.configurado():
+        try:
+            resposta = llm.chat(
+                [
+                    {
+                        "role": "system",
+                        "content": (
+                            "Você é assistente comercial. Responda APENAS JSON: "
+                            '{"resumo": "uma frase", "tags": ["até 3 tags"]}'
+                        ),
+                    },
+                    {
+                        "role": "user",
+                        "content": (
+                            f"Lead: {lead.get('nome')} | empresa: {lead.get('empresa')} | cidade: "
+                            f"{lead.get('cidade')} | fonte: {lead.get('fonte')} | observações: "
+                            f"{lead.get('observacoes')}"
+                        ),
+                    },
+                ],
+                temperature=0.3,
+                max_tokens=200,
+            )
+            import json as _json
+
+            dados = _json.loads(resposta[resposta.find("{") :])
+            if dados.get("resumo"):
+                patch["resumo_ia"] = dados["resumo"]
+                notas.append("Resumo gerado por IA.")
+            if dados.get("tags"):
+                patch["tags"] = dados["tags"][:3]
+        except Exception:
+            notas.append("IA indisponível no momento — enriquecimento apenas com dados locais.")
+
+    atualizado = storage.update_lead(lead_id, patch)
+    return {"ok": True, "lead": atualizado, "notas": notas}
+
+
+def calcular_completude(lead: dict) -> int:
+    campos = ["nome", "telefone", "email", "empresa", "cidade", "observacoes"]
+    preenchidos = sum(1 for c in campos if (lead.get(c) or "").strip())
+    return int(round(preenchidos / len(campos) * 100))