@danhachuel/prodmaker 0.1.2 → 0.1.3

package/app/services/llm.py

@@ -0,0 +1,183 @@
+"""Cliente LLM unificado — pool NVIDIA NIM (compatível OpenAI) + Google Gemini.
+
+Regras do pool:
+- Provedores ativos com API key, ordenados por prioridade (1 = primeiro).
+- Failover SOMENTE em erro transitório (quota, timeout, transporte, 429/5xx).
+- Erro de credencial/payload é registrado com attribution e NÃO é mascarado por outro provider.
+- Importações preguiçosas: o servidor sobe mesmo sem as dependências de LLM instaladas
+  (o erro claro aparece apenas no momento da ação que precisa do LLM).
+"""
+import json
+import re
+import time
+from pathlib import Path
+
+from .store import get_settings
+
+SEED_DIR = Path(__file__).resolve().parent.parent.parent / "seed"
+
+
+class LLMError(Exception):
+    def __init__(self, message: str, provider: str | None = None, transient: bool = False):
+        super().__init__(message)
+        self.provider = provider
+        self.transient = transient
+
+
+def list_providers(active_only: bool = True) -> list[dict]:
+    settings = get_settings()
+    providers = (settings.get("llm") or {}).get("providers") or []
+    if active_only:
+        providers = [p for p in providers if p.get("active") and (p.get("api_key") or "").strip()]
+    return sorted(providers, key=lambda p: int(p.get("priority") or 99))
+
+
+def find_provider(provider_id: str) -> dict | None:
+    for provider in list_providers(active_only=False):
+        if provider.get("id") == provider_id:
+            return provider
+    return None
+
+
+def _classify_openai_error(exc: Exception) -> bool:
+    """True = transitório (pode tentar o próximo provider)."""
+    status = getattr(exc, "status_code", None)
+    if status in (400, 401, 403, 404, 410):
+        return False
+    try:
+        from openai import AuthenticationError, BadRequestError, NotFoundError
+
+        if isinstance(exc, (AuthenticationError, BadRequestError, NotFoundError)):
+            return False
+    except Exception:
+        pass
+    return True
+
+
+def _classify_gemini_error(exc: Exception) -> bool:
+    code = getattr(exc, "code", None)
+    if code is None:
+        code = getattr(getattr(exc, "status", None), "value", None)
+    if code in (400, 401, 403, 404, 410):
+        return False
+    return True
+
+
+def _call_openai_compat(provider: dict, prompt: str, system: str | None, max_tokens: int) -> str:
+    from openai import OpenAI
+
+    client = OpenAI(
+        base_url=provider.get("base_url") or "https://integrate.api.nvidia.com/v1",
+        api_key=provider["api_key"],
+        timeout=90.0,
+    )
+    messages = []
+    if system:
+        messages.append({"role": "system", "content": system})
+    messages.append({"role": "user", "content": prompt})
+    response = client.chat.completions.create(
+        model=provider.get("model") or "",
+        messages=messages,
+        max_tokens=max_tokens,
+        temperature=0.7,
+    )
+    return response.choices[0].message.content or ""
+
+
+def _call_gemini(provider: dict, prompt: str, system: str | None, max_tokens: int) -> str:
+    from google import genai
+
+    client = genai.Client(api_key=provider["api_key"])
+    contents = f"{system}\n\n---\n\n{prompt}" if system else prompt
+    response = client.models.generate_content(
+        model=provider.get("model") or "gemini-2.5-flash",
+        contents=contents,
+    )
+    return response.text or ""
+
+
+def call_provider(provider: dict, prompt: str, system: str | None = None, max_tokens: int = 4000) -> str:
+    kind = provider.get("kind") or provider.get("id")
+    try:
+        if kind == "gemini":
+            return _call_gemini(provider, prompt, system, max_tokens)
+        return _call_openai_compat(provider, prompt, system, max_tokens)
+    except Exception as exc:  # noqa: BLE001 — classificado abaixo
+        if kind == "gemini":
+            transient = _classify_gemini_error(exc)
+        else:
+            transient = _classify_openai_error(exc)
+        raise LLMError(
+            f"[{provider.get('id')}] {type(exc).__name__}: {exc}",
+            provider=provider.get("id"),
+            transient=transient,
+        ) from exc
+
+
+def generate(prompt: str, system: str | None = None, max_tokens: int = 4000) -> dict:
+    """Gera texto usando o pool de provedores ativos, com failover transitório."""
+    providers = list_providers()
+    if not providers:
+        raise LLMError(
+            "Nenhum provedor LLM ativo com API key. Configure NVIDIA NIM ou Gemini em Chaves de API."
+        )
+    transient_errors = []
+    for provider in providers:
+        try:
+            text = call_provider(provider, prompt, system, max_tokens)
+            return {"text": text, "provider": provider.get("id"), "model": provider.get("model")}
+        except LLMError as exc:
+            if not exc.transient:
+                raise
+            transient_errors.append(str(exc))
+    raise LLMError(
+        "Todos os provedores ativos falharam (erros transitórios): " + " | ".join(transient_errors),
+        transient=True,
+    )
+
+
+def test_provider(provider_id: str) -> dict:
+    provider = find_provider(provider_id)
+    if not provider:
+        raise LLMError(f"Provedor '{provider_id}' não encontrado nas configurações.")
+    if not (provider.get("api_key") or "").strip():
+        raise LLMError(f"Provedor '{provider_id}' sem API key configurada.")
+    started = time.time()
+    text = call_provider(provider, "Responda apenas com a palavra: OK", max_tokens=16)
+    latency = int((time.time() - started) * 1000)
+    return {
+        "ok": True,
+        "provider": provider_id,
+        "model": provider.get("model"),
+        "latency_ms": latency,
+        "resposta": (text or "").strip()[:200],
+    }
+
+
+def _parse_json_safely(text: str) -> dict:
+    cleaned = re.sub(r"```(?:json)?", "", text).strip()
+    match = re.search(r"\{.*\}", cleaned, re.DOTALL)
+    if not match:
+        raise LLMError("A resposta do LLM não contém JSON válido.")
+    return json.loads(match.group(0))
+
+
+def analyze_product(produto: dict) -> dict:
+    """Análise de produto por IA (plano de ataque) — usa seed/prompts/analise-produto.md."""
+    template_path = SEED_DIR / "prompts" / "analise-produto.md"
+    template = template_path.read_text(encoding="utf-8") if template_path.exists() else ""
+    prompt = (
+        template.replace("{NOME}", produto.get("nome") or "")
+        .replace("{PLATAFORMA}", produto.get("plataforma") or "")
+        .replace("{NICHO}", produto.get("nicho") or "")
+        .replace("{PRECO}", str(produto.get("preco") or "—"))
+        .replace("{COMISSAO}", str(produto.get("comissao") or "—"))
+        .replace("{LINK}", produto.get("link_afiliado") or "")
+    )
+    result = generate(
+        prompt,
+        system="Você é um estrategista sênior de marketing de performance e afiliados. Responda SOMENTE com JSON válido, sem markdown e sem comentários.",
+        max_tokens=2000,
+    )
+    parsed = _parse_json_safely(result["text"])
+    return {"analise": parsed, "provider": result["provider"]}

package/app/services/pdf.py

@@ -0,0 +1,37 @@
+"""Geração de PDF — Markdown -> HTML (estilo A4) -> PDF via xhtml2pdf (puro Python)."""
+import re
+from pathlib import Path
+
+import markdown
+
+EMOJI_RE = re.compile("[\U00010000-\U0010FFFF]")
+
+A4_CSS = """
+<style>
+@page { size: A4; margin: 2cm; }
+body { font-family: Helvetica; font-size: 11pt; color: #1e293b; line-height: 1.5; }
+h1 { color: #7C3AED; font-size: 20pt; margin-bottom: 6pt; }
+h2 { color: #6D28D9; font-size: 14pt; margin-top: 16pt; }
+h3 { color: #4C1D95; font-size: 12pt; }
+table { border-collapse: collapse; width: 100%; margin-top: 8pt; }
+th, td { border: 1px solid #cbd5e1; padding: 6pt; font-size: 10pt; }
+th { background-color: #ede9fe; }
+blockquote { color: #64748b; }
+li { margin-bottom: 3pt; }
+</style>
+"""
+
+
+def markdown_para_pdf(md_text: str, output_path: Path) -> Path:
+    """Converte Markdown em PDF A4. Retorna o caminho do PDF gerado."""
+    from xhtml2pdf import pisa
+
+    clean = EMOJI_RE.sub("", md_text or "")
+    body = markdown.markdown(clean, extensions=["extra", "toc"])
+    html = f"<html><head><meta charset='utf-8'/>{A4_CSS}</head><body>{body}</body></html>"
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(output_path, "wb") as handle:
+        status = pisa.CreatePDF(html, dest=handle, encoding="utf-8")
+    if status.err:
+        raise RuntimeError("Falha ao gerar o PDF (xhtml2pdf).")
+    return output_path

package/app/services/store.py

@@ -0,0 +1,60 @@
+"""Storage e settings locais (compartilhados entre rotas e serviços)."""
+import json
+import os
+from pathlib import Path
+
+from fastapi import HTTPException
+
+PRODMAKER_HOME = Path(os.environ.get("PRODMAKER_HOME", str(Path.home() / "ProdMaker")))
+STORAGE = PRODMAKER_HOME / "storage"
+STATE = STORAGE / "state"
+
+DEFAULT_SETTINGS = {
+    "schema": 1,
+    "port": 8188,
+    "language": "pt-BR",
+    "theme": "light",
+    "api_keys": {},
+    "llm": {"providers": []},
+}
+
+
+def ensure_state_dir() -> None:
+    STATE.mkdir(parents=True, exist_ok=True)
+
+
+def get_settings() -> dict:
+    settings_path = STATE / "settings.json"
+    if not settings_path.exists():
+        return json.loads(json.dumps(DEFAULT_SETTINGS))
+    try:
+        data = json.loads(settings_path.read_text(encoding="utf-8"))
+        merged = json.loads(json.dumps(DEFAULT_SETTINGS))
+        merged.update(data)
+        if not isinstance(merged.get("llm"), dict):
+            merged["llm"] = {"providers": []}
+        if not isinstance(merged.get("api_keys"), dict):
+            merged["api_keys"] = {}
+        return merged
+    except json.JSONDecodeError:
+        raise HTTPException(
+            status_code=500,
+            detail="settings.json corrompido — leitura protegida. Restaure o arquivo manualmente.",
+        )
+
+
+def save_settings(data: dict) -> dict:
+    ensure_state_dir()
+    settings_path = STATE / "settings.json"
+    if settings_path.exists():
+        try:
+            json.loads(settings_path.read_text(encoding="utf-8"))
+        except json.JSONDecodeError:
+            backup = STATE / "settings.corrupt.json"
+            backup.write_text(settings_path.read_text(encoding="utf-8", errors="replace"), encoding="utf-8")
+            raise HTTPException(
+                status_code=500,
+                detail="settings.json corrompido — cópia preservada em settings.corrupt.json.",
+            )
+    settings_path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+    return data