agroplan-ai-cli 1.0.23 → 1.0.24

package/backend-template/VERSION.json

@@ -1,14 +1,17 @@
 {
-  "cli_version": "1.0.23",
-  "backend_template_version": "1.0.23",
+  "cli_version": "1.0.24",
+  "backend_template_version": "1.0.24",
   "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"
   ],
-  "generated_at": "2026-05-09T19:00:00Z"
+  "generated_at": "2026-05-09T20: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,71 @@ 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("/dashboard")
 def get_dashboard(
     lat: Optional[float] = None,
@@ -552,6 +622,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 +693,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 +953,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 +1126,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,191 @@
+"""
+Adaptador de Preços Agrícolas
+Integra preços reais no planejamento
+"""
+
+import os
+from typing import Dict, List, Optional
+from providers.price_provider import buscar_preco, buscar_precos_lote
+
+# Configuração
+PRICE_APPLY_TO_PROFIT = os.getenv("PRICE_APPLY_TO_PROFIT", "false").lower() == "true"
+
+
+def aplicar_precos_no_plano(resultado: Dict, uf: Optional[str] = None) -> Dict:
+    """
+    Aplica informações de preços no plano
+    
+    Args:
+        resultado: Resultado do AG ou cenário
+        uf: Unidade Federativa (opcional)
+    
+    Returns:
+        Resultado enriquecido com informações de preços
+    """
+    if "plano" not in resultado:
+        return resultado
+    
+    # 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
+    
+    # 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
+        
+        # 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
+        
+        # Se PRICE_APPLY_TO_PROFIT estiver ativo, recalcular lucro
+        # NOTA: Por enquanto, apenas adiciona informação sem recalcular
+        # Recálculo será implementado após validação de unidades
+    
+    # Adicionar resumo de preços ao resultado
+    resultado["precos"] = {
+        "ativo": True,
+        "source": "price-local-index",
+        "fallback_count": culturas_fallback,
+        "culturas_com_preco": culturas_com_preco,
+        "culturas_sem_preco": culturas_sem_preco,
+        "total_culturas": len(culturas),
+        "aplicado_no_lucro": PRICE_APPLY_TO_PROFIT,
+        "uf": uf
+    }
+    
+    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
+    
+    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 | Unidade | Fonte | Observação |\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", {})
+            
+            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 ""
+                observacao = preco_info.get("observacao", "")
+                
+                preco_fmt = f"R$ {preco:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".") if preco else "N/A"
+                
+                secao += f"| {cultura} | {preco_fmt} | {unidade} | {fallback_icon}{fonte} | {observacao} |\n"
+            else:
+                secao += f"| {cultura} | N/A | N/A | price-unavailable | Preço não disponível |\n"
+        
+        secao += "\n"
+        secao += "### Observações\n\n"
+        
+        if PRICE_APPLY_TO_PROFIT:
+            secao += "✅ **Os preços foram aplicados ao cálculo de lucro estimado.**\n\n"
+        else:
+            secao += "ℹ️ **Os preços são exibidos como referência, mas o cálculo de lucro ainda utiliza a base interna simulada.**\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", {})
+            
+            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 ""
+                observacao = preco_info.get("observacao", "")
+                
+                preco_fmt = f"R$ {preco:,.2f}".replace(",", "X").replace(".", ",").replace("X", ".") if preco else "N/A"
+                
+                secao += f"  {cultura}:\n"
+                secao += f"    Preço: {preco_fmt}\n"
+                secao += f"    Unidade: {unidade}\n"
+                secao += f"    Fonte: {fonte}{fallback_text}\n"
+                secao += f"    Observação: {observacao}\n\n"
+            else:
+                secao += f"  {cultura}:\n"
+                secao += f"    Preço: N/A\n"
+                secao += f"    Observação: Preço não disponível\n\n"
+        
+        secao += "Observações:\n\n"
+        
+        if PRICE_APPLY_TO_PROFIT:
+            secao += "Os preços foram aplicados ao cálculo de lucro estimado.\n\n"
+        else:
+            secao += "Os preços são exibidos como referência, mas o cálculo de lucro ainda utiliza a base interna simulada.\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/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.24",
   "description": "CLI global para AgroPlan AI - modo local acelerado",
   "type": "module",
   "bin": {