agroplan-ai-cli 1.0.23 → 1.0.25

package/backend-template/VERSION.json

@@ -1,14 +1,19 @@
 {
-  "cli_version": "1.0.23",
-  "backend_template_version": "1.0.23",
+  "cli_version": "1.0.25",
+  "backend_template_version": "1.0.25",
   "zarc_index_version": "2025-2026-fast-index-v2",
+  "price_index_version": "2025-05-reference-v1",
   "features": [
     "zarc_fast_index",
     "zarc_fallback_sorgo_mandioca",
     "soil_normalization_misto_siltoso",
     "climate_real_data",
     "hybrid_mode",
-    "report_generator_zarc_support"
+    "report_generator_zarc_support",
+    "price_provider_index_fallback",
+    "price_display_only",
+    "price_unit_normalization",
+    "market_profit_estimate"
   ],
-  "generated_at": "2026-05-09T19:00:00Z"
+  "generated_at": "2026-05-09T21:00:00Z"
 }

package/backend-template/api.py

@@ -151,6 +151,10 @@ def health():
         from providers.zarc_provider import get_zarc_status
         zarc_status = get_zarc_status()
         
+        # Verificar status de preços
+        from providers.price_provider import get_price_status
+        price_status = get_price_status()
+        
         # Carregar VERSION.json se existir
         version_info = {}
         version_path = os.path.join(os.path.dirname(__file__), "VERSION.json")
@@ -168,7 +172,8 @@ def health():
             "data_mode": DATA_MODE,
             "providers": {
                 "weather": "available" if WEATHER_PROVIDER else "disabled",
-                "zarc": zarc_status
+                "zarc": zarc_status,
+                "prices": price_status
             },
             "provider_cache": provider_cache_stats
         }
@@ -420,6 +425,104 @@ def get_zarc(
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+@app.get("/dados/precos")
+def get_precos(
+    cultura: Optional[str] = Query(None, description="Nome da cultura"),
+    uf: Optional[str] = Query(None, description="Unidade Federativa (ex: SP, PR)")
+):
+    """Obtém preços agrícolas"""
+    try:
+        # Importar provider de preços
+        from providers.price_provider import buscar_preco
+        
+        # Se cultura não foi fornecida, retornar mensagem amigável
+        if not cultura:
+            return {
+                "message": "Informe a cultura para consultar preços agrícolas.",
+                "exemplo_soja_sp": "/dados/precos?cultura=soja&uf=SP",
+                "exemplo_milho_pr": "/dados/precos?cultura=milho&uf=PR",
+                "parametros": {
+                    "cultura": "Nome da cultura (obrigatório)",
+                    "uf": "Unidade Federativa (opcional)"
+                },
+                "culturas_disponiveis": [
+                    "soja", "milho", "feijao", "trigo", "algodao", 
+                    "cafe", "cana", "arroz", "sorgo", "mandioca"
+                ]
+            }
+        
+        # Buscar preço
+        preco_data = buscar_preco(cultura=cultura, uf=uf)
+        
+        return preco_data
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/dados/precos/lote")
+def get_precos_lote(
+    uf: Optional[str] = Query(None, description="Unidade Federativa (ex: SP, PR)")
+):
+    """Obtém preços agrícolas para todas as culturas do AgroPlan"""
+    try:
+        # Importar provider de preços
+        from providers.price_provider import buscar_precos_lote
+        
+        # Culturas do AgroPlan
+        culturas = ["soja", "milho", "feijao", "trigo", "algodao", "cafe", "cana", "arroz", "sorgo", "mandioca"]
+        
+        # Buscar preços em lote
+        precos_data = buscar_precos_lote(culturas=culturas, uf=uf)
+        
+        # Estatísticas
+        total = len(precos_data)
+        com_preco = sum(1 for p in precos_data if p.get("ativo"))
+        fallback = sum(1 for p in precos_data if p.get("fallback"))
+        
+        return {
+            "uf": uf,
+            "total_culturas": total,
+            "culturas_com_preco": com_preco,
+            "culturas_fallback": fallback,
+            "precos": precos_data
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/dados/precos/comparar")
+def get_precos_comparar(
+    uf: Optional[str] = Query(None, description="Unidade Federativa (ex: SP, PR)")
+):
+    """Compara preços originais com preços normalizados para tonelada"""
+    try:
+        from providers.price_provider import buscar_precos_lote
+        from core.price_normalizer import normalizar_precos_lote, obter_estatisticas_normalizacao
+        
+        # Culturas do AgroPlan
+        culturas = ["soja", "milho", "feijao", "trigo", "algodao", "cafe", "cana", "arroz", "sorgo", "mandioca"]
+        
+        # Buscar preços em lote
+        precos_data = buscar_precos_lote(culturas=culturas, uf=uf)
+        
+        # Converter para dict por cultura
+        precos_dict = {p["cultura"]: p for p in precos_data}
+        
+        # Normalizar preços
+        precos_normalizados = normalizar_precos_lote(precos_dict)
+        
+        # Obter estatísticas
+        stats = obter_estatisticas_normalizacao(precos_normalizados)
+        
+        return {
+            "uf": uf,
+            "precos_normalizados": precos_normalizados,
+            "estatisticas": stats
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
 @app.get("/dashboard")
 def get_dashboard(
     lat: Optional[float] = None,
@@ -552,6 +655,10 @@ def get_dashboard(
             else:
                 resultado_base["zarc"] = {"ativo": False}
             
+            # Enriquecer com preços agrícolas
+            from core.price_adapter import aplicar_precos_no_plano
+            resultado_base = aplicar_precos_no_plano(resultado_base, uf=uf)
+            
             return resultado_base
         
         # Usa cache para dashboard com contexto climático
@@ -619,6 +726,13 @@ def get_recomendacoes(
         else:
             resultado["zarc"] = {"ativo": False}
         
+        # Enriquecer com preços agrícolas
+        from core.price_adapter import aplicar_precos_no_plano
+        resultado_temp = {"plano": resultado["recomendacoes"]}
+        resultado_temp = aplicar_precos_no_plano(resultado_temp, uf=uf)
+        resultado["recomendacoes"] = resultado_temp["plano"]
+        resultado["precos"] = resultado_temp.get("precos", {"ativo": False})
+        
         return resultado
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
@@ -872,6 +986,10 @@ def otimizar(request: OtimizarRequest):
         else:
             resultado_convertido["zarc"] = {"ativo": False}
         
+        # Enriquecer com preços agrícolas
+        from core.price_adapter import aplicar_precos_no_plano
+        resultado_convertido = aplicar_precos_no_plano(resultado_convertido, uf=request.uf)
+        
         return resultado_convertido
     except HTTPException:
         raise
@@ -1041,13 +1159,23 @@ def limpar_cache(request: Request):
     except Exception:
         pass
     
+    # Limpa cache de preços em memória
+    price_cache_cleared = False
+    try:
+        from providers.price_provider import clear_price_cache
+        clear_price_cache()
+        price_cache_cleared = True
+    except Exception:
+        pass
+    
     return {
         "status": "ok",
         "message": f"Cache limpo completamente.",
         "details": {
             "resultados_cache": items_removidos,
             "provider_cache": provider_items_removidos,
-            "zarc_index_cache": "cleared" if zarc_cache_cleared else "not_found"
+            "zarc_index_cache": "cleared" if zarc_cache_cleared else "not_found",
+            "price_cache": "cleared" if price_cache_cleared else "not_found"
         },
         "protected": bool(cache_admin_token)
     }

package/backend-template/core/price_adapter.py

@@ -0,0 +1,365 @@
+"""
+Adaptador de Preços Agrícolas
+Integra preços reais no planejamento com normalização de unidades
+"""
+
+import os
+import pandas as pd
+from typing import Dict, List, Optional
+from providers.price_provider import buscar_preco, buscar_precos_lote
+from core.price_normalizer import (
+    normalizar_preco_para_tonelada,
+    calcular_lucro_com_preco_normalizado,
+    obter_estatisticas_normalizacao
+)
+
+# Configuração
+PRICE_APPLY_TO_PROFIT = os.getenv("PRICE_APPLY_TO_PROFIT", "false").lower() == "true"
+
+# Cache de dados de culturas
+_culturas_cache = None
+
+def _carregar_culturas():
+    """Carrega dados de culturas do CSV (com cache)"""
+    global _culturas_cache
+    if _culturas_cache is None:
+        _culturas_cache = pd.read_csv("data/culturas.csv")
+    return _culturas_cache
+
+
+def aplicar_precos_no_plano(
+    resultado: Dict, 
+    uf: Optional[str] = None,
+    aplicar_no_lucro: bool = None
+) -> Dict:
+    """
+    Aplica informações de preços no plano com normalização de unidades
+    
+    Args:
+        resultado: Resultado do AG ou cenário
+        uf: Unidade Federativa (opcional)
+        aplicar_no_lucro: Se True, recalcula lucro com preços. Se None, usa PRICE_APPLY_TO_PROFIT
+    
+    Returns:
+        Resultado enriquecido com informações de preços e normalização
+    """
+    if "plano" not in resultado:
+        return resultado
+    
+    # Determinar se deve aplicar no lucro
+    if aplicar_no_lucro is None:
+        aplicar_no_lucro = PRICE_APPLY_TO_PROFIT
+    
+    # Coletar culturas únicas
+    culturas = list(set([item.get("cultura") for item in resultado["plano"]]))
+    
+    # Buscar preços em lote
+    precos_data = buscar_precos_lote(culturas, uf)
+    
+    # Criar mapa de preços por cultura
+    precos_map = {p["cultura"]: p for p in precos_data}
+    
+    # Estatísticas
+    culturas_com_preco = 0
+    culturas_fallback = 0
+    culturas_sem_preco = 0
+    culturas_normalizadas = 0
+    
+    # Aplicar preços no plano
+    for item in resultado["plano"]:
+        cultura = item.get("cultura")
+        preco_info = precos_map.get(cultura, {})
+        
+        # Adicionar informações de preço
+        item["preco_real"] = preco_info
+        
+        # Normalizar preço se disponível
+        if preco_info.get("ativo") and preco_info.get("preco") and preco_info.get("unidade"):
+            normalizacao = normalizar_preco_para_tonelada(
+                preco_info["preco"],
+                preco_info["unidade"]
+            )
+            
+            item["preco_normalizado"] = normalizacao
+            
+            if normalizacao.get("normalizado"):
+                culturas_normalizadas += 1
+                
+                # Buscar produtividade e custo da cultura
+                culturas_df = _carregar_culturas()
+                cultura_data = culturas_df[culturas_df['nome'] == cultura]
+                
+                if not cultura_data.empty:
+                    produtividade = float(cultura_data.iloc[0]['produtividade'])  # toneladas/ha
+                    custo = float(cultura_data.iloc[0]['custo'])  # R$/ha
+                    area = item.get("area", 0)  # ha
+                    
+                    # Adicionar campos ao item se não existirem
+                    if "produtividade" not in item:
+                        item["produtividade"] = produtividade
+                    if "custo" not in item:
+                        item["custo"] = custo
+                    
+                    # Calcular lucro de mercado estimado (sempre, independente de aplicar_no_lucro)
+                    if produtividade > 0 and area > 0:
+                        calculo_mercado = calcular_lucro_com_preco_normalizado(
+                            preco_por_tonelada=normalizacao["preco_por_tonelada"],
+                            produtividade=produtividade,
+                            custo_por_hectare=custo,
+                            area=area
+                        )
+                        
+                        item["lucro_mercado_estimado"] = calculo_mercado["lucro_mercado"]
+                        item["lucro_mercado_detalhes"] = calculo_mercado
+                        
+                        # Se aplicar_no_lucro, substituir lucro_estimado
+                        if aplicar_no_lucro:
+                            item["lucro_original"] = item.get("lucro_estimado", 0)
+                            item["lucro_estimado"] = calculo_mercado["lucro_mercado"]
+                            item["lucro_mercado_aplicado"] = True
+                        else:
+                            item["lucro_mercado_aplicado"] = False
+                    else:
+                        item["lucro_mercado_estimado"] = None
+                        item["lucro_mercado_aplicado"] = False
+                else:
+                    item["lucro_mercado_estimado"] = None
+                    item["lucro_mercado_aplicado"] = False
+            else:
+                item["lucro_mercado_estimado"] = None
+                item["lucro_mercado_aplicado"] = False
+        else:
+            item["preco_normalizado"] = {"normalizado": False}
+            item["lucro_mercado_estimado"] = None
+            item["lucro_mercado_aplicado"] = False
+        
+        # Contabilizar estatísticas
+        if preco_info.get("ativo"):
+            if preco_info.get("fallback"):
+                culturas_fallback += 1
+            else:
+                culturas_com_preco += 1
+        else:
+            culturas_sem_preco += 1
+    
+    # Recalcular lucro_total se aplicar_no_lucro
+    if aplicar_no_lucro:
+        resultado["lucro_total_original"] = resultado.get("lucro_total", 0)
+        resultado["lucro_total"] = sum(
+            item.get("lucro_estimado", 0) for item in resultado["plano"]
+        )
+    
+    # Adicionar resumo de preços ao resultado
+    resultado["precos"] = {
+        "ativo": True,
+        "source": "price-local-index" if culturas_com_preco > 0 else "price-fallback",
+        "fallback_count": culturas_fallback,
+        "culturas_com_preco": culturas_com_preco,
+        "culturas_sem_preco": culturas_sem_preco,
+        "total_culturas": len(culturas),
+        "aplicado_no_lucro": aplicar_no_lucro,
+        "lucro_recalculado_disponivel": any(
+            item.get("lucro_mercado_estimado") is not None 
+            for item in resultado["plano"]
+        ),
+        "uf": uf,
+        "normalizacao": {
+            "ativa": True,
+            "unidade_base": "tonelada",
+            "culturas_normalizadas": culturas_normalizadas,
+            "culturas_nao_normalizadas": len(culturas) - culturas_normalizadas
+        }
+    }
+    
+    return resultado
+
+
+def gerar_secao_precos_relatorio(plano: List[Dict], uf: Optional[str], formato: str = "md") -> str:
+    """
+    Gera seção de preços para o relatório com informações de normalização
+    
+    Args:
+        plano: Lista de itens do plano com informações de preços
+        uf: Unidade Federativa
+        formato: 'md' ou 'txt'
+    
+    Returns:
+        String com seção formatada
+    """
+    if formato == "md":
+        secao = "## 💰 Preços Agrícolas Utilizados\n\n"
+        
+        if uf:
+            secao += f"**Região:** {uf}\n\n"
+        
+        secao += "### Preços por Cultura\n\n"
+        secao += "| Cultura | Preço Original | Unidade | Preço/Tonelada | Normalizado | Fonte |\n"
+        secao += "|---------|----------------|---------|----------------|-------------|-------|\n"
+        
+        # Coletar culturas únicas
+        culturas_vistas = set()
+        
+        for item in plano:
+            cultura = item.get("cultura", "").upper()
+            
+            if cultura in culturas_vistas:
+                continue
+            
+            culturas_vistas.add(cultura)
+            
+            preco_info = item.get("preco_real", {})
+            preco_norm = item.get("preco_normalizado", {})
+            
+            if preco_info.get("ativo"):
+                preco = preco_info.get("preco")
+                unidade = preco_info.get("unidade", "N/A")
+                fonte = preco_info.get("source", "N/A")
+                fallback_icon = "⚠️ " if preco_info.get("fallback") else ""
+                
+                preco_fmt = f"R$ {preco:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".") if preco else "N/A"
+                
+                # Informações de normalização
+                if preco_norm.get("normalizado"):
+                    preco_ton = preco_norm.get("preco_por_tonelada", 0)
+                    preco_ton_fmt = f"R$ {preco_ton:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+                    norm_status = "✅ Sim"
+                else:
+                    preco_ton_fmt = "N/A"
+                    norm_status = "❌ Não"
+                
+                secao += f"| {cultura} | {preco_fmt} | {unidade} | {preco_ton_fmt} | {norm_status} | {fallback_icon}{fonte} |\n"
+            else:
+                secao += f"| {cultura} | N/A | N/A | N/A | ❌ Não | price-unavailable |\n"
+        
+        secao += "\n"
+        
+        # Adicionar informações de lucro de mercado se disponível
+        tem_lucro_mercado = any(item.get("lucro_mercado_estimado") is not None for item in plano)
+        
+        if tem_lucro_mercado:
+            secao += "### Comparação de Lucro\n\n"
+            secao += "| Talhão | Cultura | Lucro Sistema | Lucro Mercado | Diferença |\n"
+            secao += "|--------|---------|---------------|---------------|----------|\n"
+            
+            for item in plano:
+                if item.get("lucro_mercado_estimado") is not None:
+                    talhao = item.get("talhao", "N/A")
+                    cultura = item.get("cultura", "").upper()
+                    lucro_sistema = item.get("lucro_original", item.get("lucro_estimado", 0))
+                    lucro_mercado = item.get("lucro_mercado_estimado", 0)
+                    diferenca = lucro_mercado - lucro_sistema
+                    
+                    lucro_sistema_fmt = f"R$ {lucro_sistema:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+                    lucro_mercado_fmt = f"R$ {lucro_mercado:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+                    diferenca_fmt = f"R$ {diferenca:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+                    diferenca_icon = "📈" if diferenca > 0 else "📉" if diferenca < 0 else "➡️"
+                    
+                    secao += f"| {talhao} | {cultura} | {lucro_sistema_fmt} | {lucro_mercado_fmt} | {diferenca_icon} {diferenca_fmt} |\n"
+            
+            secao += "\n"
+        
+        secao += "### Observações\n\n"
+        
+        if PRICE_APPLY_TO_PROFIT:
+            secao += "✅ **Os preços de mercado normalizados foram aplicados ao cálculo de lucro.**\n\n"
+        else:
+            secao += "ℹ️ **Os preços foram normalizados para R$/tonelada. Nesta versão, o lucro principal ainda usa a base interna do sistema, mas o lucro de mercado estimado é exibido para comparação.**\n\n"
+        
+        secao += "**Normalização de Unidades:**\n"
+        secao += "- Todos os preços foram convertidos para R$/tonelada para permitir comparação consistente\n"
+        secao += "- Fatores de conversão: saca_60kg (×16.67), saca_50kg (×20), arroba_15kg (×66.67)\n\n"
+        
+        secao += "**Fontes:**\n"
+        secao += "- `price-local-index`: Índice local de preços\n"
+        secao += "- `price-fallback`: Preço de referência (fallback)\n"
+        secao += "- `price-unavailable`: Preço não disponível\n"
+        
+    else:  # txt
+        secao = "PREÇOS AGRÍCOLAS UTILIZADOS\n\n"
+        
+        if uf:
+            secao += f"Região: {uf}\n\n"
+        
+        secao += "Preços por Cultura:\n\n"
+        
+        # Coletar culturas únicas
+        culturas_vistas = set()
+        
+        for item in plano:
+            cultura = item.get("cultura", "").upper()
+            
+            if cultura in culturas_vistas:
+                continue
+            
+            culturas_vistas.add(cultura)
+            
+            preco_info = item.get("preco_real", {})
+            preco_norm = item.get("preco_normalizado", {})
+            
+            if preco_info.get("ativo"):
+                preco = preco_info.get("preco")
+                unidade = preco_info.get("unidade", "N/A")
+                fonte = preco_info.get("source", "N/A")
+                fallback_text = " (fallback)" if preco_info.get("fallback") else ""
+                
+                preco_fmt = f"R$ {preco:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".") if preco else "N/A"
+                
+                secao += f"  {cultura}:\n"
+                secao += f"    Preço Original: {preco_fmt}\n"
+                secao += f"    Unidade: {unidade}\n"
+                
+                if preco_norm.get("normalizado"):
+                    preco_ton = preco_norm.get("preco_por_tonelada", 0)
+                    preco_ton_fmt = f"R$ {preco_ton:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+                    secao += f"    Preço/Tonelada: {preco_ton_fmt}\n"
+                    secao += f"    Normalizado: Sim\n"
+                else:
+                    secao += f"    Normalizado: Não\n"
+                
+                secao += f"    Fonte: {fonte}{fallback_text}\n\n"
+            else:
+                secao += f"  {cultura}:\n"
+                secao += f"    Preço: N/A\n"
+                secao += f"    Normalizado: Não\n"
+                secao += f"    Observação: Preço não disponível\n\n"
+        
+        # Adicionar comparação de lucro se disponível
+        tem_lucro_mercado = any(item.get("lucro_mercado_estimado") is not None for item in plano)
+        
+        if tem_lucro_mercado:
+            secao += "Comparação de Lucro:\n\n"
+            
+            for item in plano:
+                if item.get("lucro_mercado_estimado") is not None:
+                    talhao = item.get("talhao", "N/A")
+                    cultura = item.get("cultura", "").upper()
+                    lucro_sistema = item.get("lucro_original", item.get("lucro_estimado", 0))
+                    lucro_mercado = item.get("lucro_mercado_estimado", 0)
+                    diferenca = lucro_mercado - lucro_sistema
+                    
+                    lucro_sistema_fmt = f"R$ {lucro_sistema:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+                    lucro_mercado_fmt = f"R$ {lucro_mercado:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+                    diferenca_fmt = f"R$ {diferenca:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".")
+                    
+                    secao += f"  Talhão {talhao} ({cultura}):\n"
+                    secao += f"    Lucro Sistema: {lucro_sistema_fmt}\n"
+                    secao += f"    Lucro Mercado: {lucro_mercado_fmt}\n"
+                    secao += f"    Diferença: {diferenca_fmt}\n\n"
+        
+        secao += "Observações:\n\n"
+        
+        if PRICE_APPLY_TO_PROFIT:
+            secao += "Os preços de mercado normalizados foram aplicados ao cálculo de lucro.\n\n"
+        else:
+            secao += "Os preços foram normalizados para R$/tonelada. Nesta versão, o lucro principal ainda usa a base interna do sistema, mas o lucro de mercado estimado é exibido para comparação.\n\n"
+        
+        secao += "Normalização de Unidades:\n"
+        secao += "- Todos os preços foram convertidos para R$/tonelada\n"
+        secao += "- Fatores: saca_60kg (x16.67), saca_50kg (x20), arroba_15kg (x66.67)\n\n"
+        
+        secao += "Fontes:\n"
+        secao += "- price-local-index: Índice local de preços\n"
+        secao += "- price-fallback: Preço de referência (fallback)\n"
+        secao += "- price-unavailable: Preço não disponível\n"
+    
+    return secao

package/backend-template/core/price_normalizer.py

@@ -0,0 +1,182 @@
+"""
+Normalizador de Unidades de Preços Agrícolas
+
+Converte preços de diferentes unidades para uma base comum (R$/tonelada)
+para permitir comparação e cálculo consistente de lucro.
+"""
+
+from typing import Dict, Optional
+
+
+# Fatores de conversão para tonelada
+CONVERSAO_UNIDADES = {
+    "tonelada": 1.0,
+    "saca_60kg": 1000.0 / 60.0,  # 16.6667 sacas por tonelada
+    "saca_50kg": 1000.0 / 50.0,  # 20 sacas por tonelada
+    "arroba_15kg": 1000.0 / 15.0,  # 66.6667 arrobas por tonelada
+}
+
+
+def normalizar_preco_para_tonelada(preco: float, unidade: str) -> Dict:
+    """
+    Converte preço de qualquer unidade para R$/tonelada.
+    
+    Args:
+        preco: Preço na unidade original
+        unidade: Unidade do preço (tonelada, saca_60kg, saca_50kg, arroba_15kg)
+    
+    Returns:
+        Dict com informações de normalização:
+        - preco_original: Preço original
+        - unidade_original: Unidade original
+        - preco_por_tonelada: Preço convertido para R$/tonelada
+        - unidade_normalizada: "tonelada"
+        - fator_conversao: Fator usado na conversão
+        - normalizado: True se conversão foi bem-sucedida
+        - error: Mensagem de erro se conversão falhou
+    """
+    
+    # Normalizar nome da unidade (remover espaços, lowercase)
+    unidade_normalizada = unidade.lower().strip().replace(" ", "_")
+    
+    # Verificar se unidade é suportada
+    if unidade_normalizada not in CONVERSAO_UNIDADES:
+        return {
+            "preco_original": preco,
+            "unidade_original": unidade,
+            "normalizado": False,
+            "error": f"Unidade '{unidade}' não suportada. Unidades válidas: {', '.join(CONVERSAO_UNIDADES.keys())}"
+        }
+    
+    # Obter fator de conversão
+    fator = CONVERSAO_UNIDADES[unidade_normalizada]
+    
+    # Calcular preço por tonelada
+    preco_por_tonelada = preco * fator
+    
+    return {
+        "preco_original": preco,
+        "unidade_original": unidade,
+        "preco_por_tonelada": round(preco_por_tonelada, 2),
+        "unidade_normalizada": "tonelada",
+        "fator_conversao": round(fator, 4),
+        "normalizado": True
+    }
+
+
+def normalizar_precos_lote(precos: Dict[str, Dict]) -> Dict[str, Dict]:
+    """
+    Normaliza preços de múltiplas culturas em lote.
+    
+    Args:
+        precos: Dict com culturas como chave e dados de preço como valor
+    
+    Returns:
+        Dict com culturas como chave e dados normalizados como valor
+    """
+    resultado = {}
+    
+    for cultura, dados_preco in precos.items():
+        if not dados_preco.get("ativo", False):
+            resultado[cultura] = {
+                **dados_preco,
+                "normalizado": False,
+                "error": "Preço não disponível"
+            }
+            continue
+        
+        preco = dados_preco.get("preco")
+        unidade = dados_preco.get("unidade")
+        
+        if preco is None or unidade is None:
+            resultado[cultura] = {
+                **dados_preco,
+                "normalizado": False,
+                "error": "Dados de preço incompletos"
+            }
+            continue
+        
+        # Normalizar preço
+        normalizacao = normalizar_preco_para_tonelada(preco, unidade)
+        
+        # Combinar dados originais com normalização
+        resultado[cultura] = {
+            **dados_preco,
+            **normalizacao
+        }
+    
+    return resultado
+
+
+def calcular_lucro_com_preco_normalizado(
+    preco_por_tonelada: float,
+    produtividade: float,  # toneladas por hectare
+    custo_por_hectare: float,
+    area: float
+) -> Dict:
+    """
+    Calcula lucro usando preço normalizado de mercado.
+    
+    Args:
+        preco_por_tonelada: Preço normalizado em R$/tonelada
+        produtividade: Produtividade em toneladas por hectare
+        custo_por_hectare: Custo de produção por hectare
+        area: Área em hectares
+    
+    Returns:
+        Dict com cálculos detalhados:
+        - receita_total: Receita bruta
+        - custo_total: Custo total de produção
+        - lucro_mercado: Lucro líquido com preço de mercado
+        - lucro_por_hectare: Lucro por hectare
+    """
+    
+    # Calcular receita
+    producao_total = produtividade * area  # toneladas
+    receita_total = preco_por_tonelada * producao_total
+    
+    # Calcular custo
+    custo_total = custo_por_hectare * area
+    
+    # Calcular lucro
+    lucro_mercado = receita_total - custo_total
+    lucro_por_hectare = lucro_mercado / area if area > 0 else 0
+    
+    return {
+        "receita_total": round(receita_total, 2),
+        "custo_total": round(custo_total, 2),
+        "lucro_mercado": round(lucro_mercado, 2),
+        "lucro_por_hectare": round(lucro_por_hectare, 2),
+        "producao_total_toneladas": round(producao_total, 2)
+    }
+
+
+def obter_estatisticas_normalizacao(precos_normalizados: Dict[str, Dict]) -> Dict:
+    """
+    Gera estatísticas sobre normalização de preços.
+    
+    Args:
+        precos_normalizados: Dict com preços normalizados
+    
+    Returns:
+        Dict com estatísticas de normalização
+    """
+    total = len(precos_normalizados)
+    normalizados = sum(1 for p in precos_normalizados.values() if p.get("normalizado", False))
+    nao_normalizados = total - normalizados
+    
+    # Agrupar por unidade original
+    unidades = {}
+    for cultura, dados in precos_normalizados.items():
+        if dados.get("normalizado", False):
+            unidade = dados.get("unidade_original", "desconhecida")
+            unidades[unidade] = unidades.get(unidade, 0) + 1
+    
+    return {
+        "ativa": True,
+        "unidade_base": "tonelada",
+        "total_culturas": total,
+        "culturas_normalizadas": normalizados,
+        "culturas_nao_normalizadas": nao_normalizados,
+        "unidades_originais": unidades
+    }

package/backend-template/core/report_generator.py

@@ -162,6 +162,13 @@ def gerar_relatorio_completo(culturas, talhoes, regras, objetivo='equilibrado',
         secao_zarc = gerar_secao_zarc_relatorio(resultado_temp["plano"], uf, municipio, safra, formato)
         conteudo += "\n\n" + secao_zarc
     
+    # Adicionar seção de preços agrícolas
+    from core.price_adapter import aplicar_precos_no_plano, gerar_secao_precos_relatorio
+    resultado_temp = {"plano": resultado_ag["plano"]}
+    resultado_temp = aplicar_precos_no_plano(resultado_temp, uf=uf)
+    secao_precos = gerar_secao_precos_relatorio(resultado_temp["plano"], uf, formato)
+    conteudo += "\n\n" + secao_precos
+    
     # Salva arquivo
     os.makedirs('reports', exist_ok=True)
     timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')

package/backend-template/data/precos/precos_fallback.json

@@ -0,0 +1,87 @@
+{
+  "generated_at": "2026-05-09T19:30:00Z",
+  "source": "price-fallback",
+  "description": "Preços de referência para fallback quando dados reais não estão disponíveis",
+  "precos": [
+    {
+      "cultura": "soja",
+      "preco": 128.50,
+      "unidade": "saca_60kg",
+      "fonte": "fallback",
+      "fallback": true,
+      "observacao": "Preço de referência baseado em média histórica"
+    },
+    {
+      "cultura": "milho",
+      "preco": 65.00,
+      "unidade": "saca_60kg",
+      "fonte": "fallback",
+      "fallback": true,
+      "observacao": "Preço de referência baseado em média histórica"
+    },
+    {
+      "cultura": "feijao",
+      "preco": 180.00,
+      "unidade": "saca_60kg",
+      "fonte": "fallback",
+      "fallback": true,
+      "observacao": "Preço de referência baseado em média histórica"
+    },
+    {
+      "cultura": "trigo",
+      "preco": 75.00,
+      "unidade": "saca_60kg",
+      "fonte": "fallback",
+      "fallback": true,
+      "observacao": "Preço de referência baseado em média histórica"
+    },
+    {
+      "cultura": "algodao",
+      "preco": 3200.00,
+      "unidade": "arroba_15kg",
+      "fonte": "fallback",
+      "fallback": true,
+      "observacao": "Preço de referência baseado em média histórica"
+    },
+    {
+      "cultura": "cafe",
+      "preco": 1250.00,
+      "unidade": "saca_60kg",
+      "fonte": "fallback",
+      "fallback": true,
+      "observacao": "Preço de referência baseado em média histórica"
+    },
+    {
+      "cultura": "cana",
+      "preco": 95.00,
+      "unidade": "tonelada",
+      "fonte": "fallback",
+      "fallback": true,
+      "observacao": "Preço de referência baseado em média histórica"
+    },
+    {
+      "cultura": "arroz",
+      "preco": 85.00,
+      "unidade": "saca_50kg",
+      "fonte": "fallback",
+      "fallback": true,
+      "observacao": "Preço de referência baseado em média histórica"
+    },
+    {
+      "cultura": "sorgo",
+      "preco": 55.00,
+      "unidade": "saca_60kg",
+      "fonte": "fallback",
+      "fallback": true,
+      "observacao": "Preço de referência baseado em média histórica"
+    },
+    {
+      "cultura": "mandioca",
+      "preco": 450.00,
+      "unidade": "tonelada",
+      "fonte": "fallback",
+      "fallback": true,
+      "observacao": "Preço de referência baseado em média histórica"
+    }
+  ]
+}

package/backend-template/data/precos/precos_index.json

@@ -0,0 +1,58 @@
+{
+  "generated_at": "2026-05-09T19:30:00Z",
+  "source": "price-local-index",
+  "description": "Índice local de preços agrícolas - será substituído por dados reais futuramente",
+  "version": "1.0.0",
+  "records": {
+    "soja_SP": {
+      "cultura": "soja",
+      "uf": "SP",
+      "preco": 130.00,
+      "unidade": "saca_60kg",
+      "fonte": "price-local-index",
+      "fallback": false,
+      "data_referencia": "2026-05-01",
+      "observacao": "Preço de referência para SP"
+    },
+    "milho_SP": {
+      "cultura": "milho",
+      "uf": "SP",
+      "preco": 67.00,
+      "unidade": "saca_60kg",
+      "fonte": "price-local-index",
+      "fallback": false,
+      "data_referencia": "2026-05-01",
+      "observacao": "Preço de referência para SP"
+    },
+    "feijao_SP": {
+      "cultura": "feijao",
+      "uf": "SP",
+      "preco": 185.00,
+      "unidade": "saca_60kg",
+      "fonte": "price-local-index",
+      "fallback": false,
+      "data_referencia": "2026-05-01",
+      "observacao": "Preço de referência para SP"
+    },
+    "cafe_SP": {
+      "cultura": "cafe",
+      "uf": "SP",
+      "preco": 1280.00,
+      "unidade": "saca_60kg",
+      "fonte": "price-local-index",
+      "fallback": false,
+      "data_referencia": "2026-05-01",
+      "observacao": "Preço de referência para SP"
+    },
+    "cana_SP": {
+      "cultura": "cana",
+      "uf": "SP",
+      "preco": 98.00,
+      "unidade": "tonelada",
+      "fonte": "price-local-index",
+      "fallback": false,
+      "data_referencia": "2026-05-01",
+      "observacao": "Preço de referência para SP"
+    }
+  }
+}

package/backend-template/providers/price_provider.py

@@ -0,0 +1,219 @@
+"""
+Provider de Preços Agrícolas
+Fornece preços reais ou de referência para culturas
+"""
+
+import os
+import json
+from typing import Optional, Dict, List
+
+# Configurações
+PRICE_PROVIDER = os.getenv("PRICE_PROVIDER", "local")  # local, conab, disabled
+PRICE_INDEX_PATH = os.path.join(os.path.dirname(__file__), "..", "data", "precos", "precos_index.json")
+PRICE_FALLBACK_PATH = os.path.join(os.path.dirname(__file__), "..", "data", "precos", "precos_fallback.json")
+
+# Cache em memória para índice de preços
+_price_index_cache = None
+_price_fallback_cache = None
+
+
+def normalizar_cultura_preco(cultura: str) -> str:
+    """Normaliza nome da cultura para busca de preços"""
+    mapping = {
+        "café": "cafe",
+        "feijão": "feijao",
+        "algodão": "algodao",
+        "CAFÉ": "cafe",
+        "FEIJÃO": "feijao",
+        "ALGODÃO": "algodao",
+        "Café": "cafe",
+        "Feijão": "feijao",
+        "Algodão": "algodao"
+    }
+    cultura_normalizada = mapping.get(cultura, cultura)
+    return cultura_normalizada.lower().strip()
+
+
+def load_price_index() -> Optional[Dict]:
+    """Carrega índice de preços do arquivo JSON"""
+    global _price_index_cache
+    
+    if _price_index_cache is not None:
+        return _price_index_cache
+    
+    if not os.path.exists(PRICE_INDEX_PATH):
+        return None
+    
+    try:
+        with open(PRICE_INDEX_PATH, 'r', encoding='utf-8') as f:
+            _price_index_cache = json.load(f)
+        return _price_index_cache
+    except Exception as e:
+        print(f"Erro ao carregar índice de preços: {e}")
+        return None
+
+
+def load_price_fallback() -> List[Dict]:
+    """Carrega preços de fallback do arquivo JSON"""
+    global _price_fallback_cache
+    
+    if _price_fallback_cache is not None:
+        return _price_fallback_cache
+    
+    if not os.path.exists(PRICE_FALLBACK_PATH):
+        return []
+    
+    try:
+        with open(PRICE_FALLBACK_PATH, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+            _price_fallback_cache = data.get("precos", [])
+        return _price_fallback_cache
+    except Exception as e:
+        print(f"Erro ao carregar preços de fallback: {e}")
+        return []
+
+
+def buscar_preco_no_indice(cultura: str, uf: Optional[str] = None) -> Optional[Dict]:
+    """Busca preço no índice local"""
+    price_index = load_price_index()
+    
+    if not price_index:
+        return None
+    
+    records = price_index.get("records", {})
+    
+    # Tentar buscar com UF específica
+    if uf:
+        key = f"{cultura}_{uf.upper()}"
+        if key in records:
+            return records[key]
+    
+    # Tentar buscar sem UF (genérico)
+    for key, record in records.items():
+        if record.get("cultura") == cultura and not uf:
+            return record
+    
+    return None
+
+
+def buscar_preco_no_fallback(cultura: str) -> Optional[Dict]:
+    """Busca preço no fallback"""
+    fallback_data = load_price_fallback()
+    
+    for item in fallback_data:
+        if item.get("cultura") == cultura:
+            return item
+    
+    return None
+
+
+def buscar_preco(cultura: str, uf: Optional[str] = None) -> Dict:
+    """
+    Busca preço de uma cultura
+    
+    Args:
+        cultura: Nome da cultura
+        uf: Unidade Federativa (opcional)
+    
+    Returns:
+        Dicionário com informações de preço (sempre retorna, nunca None)
+    """
+    # Normalizar cultura
+    cultura_normalizada = normalizar_cultura_preco(cultura)
+    
+    # Se provider desabilitado, retornar inativo
+    if PRICE_PROVIDER == "disabled":
+        return {
+            "ativo": False,
+            "source": "price-disabled",
+            "fallback": False,
+            "cultura": cultura,
+            "uf": uf,
+            "preco": None,
+            "unidade": None,
+            "data_referencia": None,
+            "observacao": "Provider de preços desabilitado"
+        }
+    
+    # Tentar buscar no índice local
+    preco_data = buscar_preco_no_indice(cultura_normalizada, uf)
+    
+    if preco_data:
+        return {
+            "ativo": True,
+            "source": preco_data.get("fonte", "price-local-index"),
+            "fallback": preco_data.get("fallback", False),
+            "cultura": cultura,
+            "uf": uf or preco_data.get("uf"),
+            "preco": preco_data.get("preco"),
+            "unidade": preco_data.get("unidade"),
+            "data_referencia": preco_data.get("data_referencia"),
+            "observacao": preco_data.get("observacao", "Preço obtido do índice local")
+        }
+    
+    # Tentar fallback
+    preco_data = buscar_preco_no_fallback(cultura_normalizada)
+    
+    if preco_data:
+        return {
+            "ativo": True,
+            "source": "price-fallback",
+            "fallback": True,
+            "cultura": cultura,
+            "uf": uf,
+            "preco": preco_data.get("preco"),
+            "unidade": preco_data.get("unidade"),
+            "data_referencia": None,
+            "observacao": preco_data.get("observacao", "Preço de referência (fallback)")
+        }
+    
+    # Nenhum preço encontrado
+    return {
+        "ativo": False,
+        "source": "price-unavailable",
+        "fallback": False,
+        "cultura": cultura,
+        "uf": uf,
+        "preco": None,
+        "unidade": None,
+        "data_referencia": None,
+        "observacao": "Preço não disponível para esta cultura"
+    }
+
+
+def buscar_precos_lote(culturas: List[str], uf: Optional[str] = None) -> List[Dict]:
+    """
+    Busca preços para múltiplas culturas
+    
+    Args:
+        culturas: Lista de nomes de culturas
+        uf: Unidade Federativa (opcional)
+    
+    Returns:
+        Lista de dicionários com informações de preço
+    """
+    return [buscar_preco(cultura, uf) for cultura in culturas]
+
+
+def get_price_status() -> Dict:
+    """Retorna status do provider de preços"""
+    price_index = load_price_index()
+    fallback_data = load_price_fallback()
+    
+    index_count = len(price_index.get("records", {})) if price_index else 0
+    fallback_count = len(fallback_data)
+    
+    return {
+        "provider": PRICE_PROVIDER,
+        "index_available": price_index is not None,
+        "index_records": index_count,
+        "fallback_records": fallback_count,
+        "total_culturas_cobertas": index_count + fallback_count
+    }
+
+
+def clear_price_cache():
+    """Limpa cache de preços em memória"""
+    global _price_index_cache, _price_fallback_cache
+    _price_index_cache = None
+    _price_fallback_cache = None

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agroplan-ai-cli",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "description": "CLI global para AgroPlan AI - modo local acelerado",
   "type": "module",
   "bin": {