agroplan-ai-cli 1.0.27 → 1.0.29

package/backend-template/.env.example

@@ -20,6 +20,10 @@ DATA_MODE=hybrid
 WEATHER_PROVIDER=open-meteo
 PROVIDER_CACHE_TTL=3600
 
+# Debug Configuration
+# Set to true to expose detailed error tracebacks (development only)
+DEBUG_ERRORS=false
+
 # Cache Administration (optional)
 # If set, /cache/limpar endpoint requires X-Cache-Token header
 # Leave empty to disable protection (not recommended for production)

package/backend-template/VERSION.json

@@ -1,6 +1,6 @@
 {
-  "cli_version": "1.0.27",
-  "backend_template_version": "1.0.27",
+  "cli_version": "1.0.29",
+  "backend_template_version": "1.0.29",
   "zarc_index_version": "2025-2026-fast-index-v2",
   "price_index_version": "2025-05-reference-v1",
   "features": [
@@ -15,7 +15,9 @@
     "price_unit_normalization",
     "market_profit_estimate",
     "market_profit_validation",
-    "market_profit_confidence_refinement"
+    "market_profit_confidence_refinement",
+    "market_profit_comparative_evaluation",
+    "market_profit_experimental_optimizer"
   ],
-  "generated_at": "2026-05-09T23:00:00Z"
+  "generated_at": "2026-05-09T23:45:00Z"
 }

package/backend-template/api.py

@@ -28,6 +28,7 @@ CORS_ORIGINS = os.getenv("CORS_ORIGINS", "http://localhost:3000,http://127.0.0.1
 DATA_MODE = os.getenv("DATA_MODE", "hybrid")  # simulated, real, hybrid
 WEATHER_PROVIDER = os.getenv("WEATHER_PROVIDER", "open-meteo")
 PROVIDER_CACHE_TTL = int(os.getenv("PROVIDER_CACHE_TTL", "3600"))
+DEBUG_ERRORS = os.getenv("DEBUG_ERRORS", "false").lower() == "true"
 
 # Cache em memória para resultados pesados
 _resultados_cache = {}
@@ -580,6 +581,69 @@ def get_debug_lucro_mercado(
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+@app.get("/comparar/lucro-mercado")
+def comparar_lucro_mercado(
+    objetivo: str = Query("equilibrado", description="Objetivo de otimização"),
+    seed: int = Query(42, description="Seed para reprodutibilidade"),
+    geracoes: int = Query(100, description="Número de gerações do AG"),
+    populacao: int = Query(50, description="Tamanho da população"),
+    lat: Optional[float] = Query(None, description="Latitude"),
+    lon: Optional[float] = Query(None, description="Longitude"),
+    days: int = Query(30, description="Dias para análise climática"),
+    uf: Optional[str] = Query(None, description="Unidade Federativa (ex: SP, PR)"),
+    municipio: Optional[str] = Query(None, description="Município"),
+    safra: str = Query("2025/2026", description="Safra ZARC")
+):
+    """
+    Avalia o plano do sistema usando lucro de mercado para comparação.
+    
+    NÃO gera um plano otimizado por mercado. Apenas:
+    1. Gera plano normal com AG usando lucro do sistema
+    2. Avalia esse mesmo plano com lucro de mercado normalizado
+    3. Compara os dois valores de lucro
+    
+    Retorna:
+    - modo: "avaliacao_comparativa"
+    - plano_sistema: Plano otimizado pelo AG normal
+    - avaliacao_mercado: Avaliação do mesmo plano com lucro de mercado
+    - comparacao: Diferenças e validação
+    """
+    try:
+        from core.market_profit_comparator import comparar_plano_sistema_com_avaliacao_mercado
+        
+        culturas, talhoes, regras = get_dados()
+        
+        resultado = comparar_plano_sistema_com_avaliacao_mercado(
+            culturas=culturas,
+            talhoes=talhoes,
+            regras=regras,
+            uf=uf,
+            municipio=municipio,
+            safra=safra,
+            objetivo=objetivo,
+            seed=seed,
+            geracoes=geracoes,
+            populacao=populacao
+        )
+        
+        return converter_tipos_python(resultado)
+        
+    except Exception as e:
+        import traceback
+        if DEBUG_ERRORS:
+            raise HTTPException(
+                status_code=500,
+                detail={
+                    "error": str(e),
+                    "traceback": traceback.format_exc()
+                }
+            )
+        else:
+            raise HTTPException(
+                status_code=500,
+                detail="Erro ao gerar avaliação comparativa de lucro de mercado."
+            )
+
 @app.get("/dashboard")
 def get_dashboard(
     lat: Optional[float] = None,
@@ -1178,6 +1242,72 @@ def relatorio(request: RelatorioRequest):
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+@app.get("/otimizar/lucro-mercado-experimental")
+def otimizar_lucro_mercado_experimental(
+    objetivo: str = Query("mercado", description="Objetivo (sempre 'mercado' para este modo)"),
+    seed: int = Query(42, description="Seed para reprodutibilidade"),
+    geracoes: int = Query(50, description="Número de gerações do AG"),
+    populacao: int = Query(50, description="Tamanho da população"),
+    lat: Optional[float] = Query(None, description="Latitude"),
+    lon: Optional[float] = Query(None, description="Longitude"),
+    days: int = Query(30, description="Dias para análise climática"),
+    uf: Optional[str] = Query(None, description="Unidade Federativa (ex: SP, PR)"),
+    municipio: Optional[str] = Query(None, description="Município"),
+    safra: str = Query("2025/2026", description="Safra ZARC")
+):
+    """
+    Otimização EXPERIMENTAL usando lucro de mercado como fitness.
+    
+    ATENÇÃO: Este é um modo experimental que:
+    - Usa lucro_mercado_estimado como fitness principal
+    - Bloqueia uso automático se houver itens críticos
+    - NÃO substitui a recomendação principal do sistema
+    - Requer validação manual antes de usar
+    
+    Retorna:
+    - modo: "otimizacao_mercado_experimental"
+    - experimental: true
+    - plano: Plano otimizado por lucro de mercado
+    - bloqueado: true/false
+    - motivo_bloqueio: Razão do bloqueio (se aplicável)
+    - aviso: Texto de aviso sobre natureza experimental
+    """
+    try:
+        from core.market_profit_optimizer import gerar_plano_genetico_lucro_mercado_experimental
+        
+        culturas, talhoes, regras = get_dados()
+        
+        resultado = gerar_plano_genetico_lucro_mercado_experimental(
+            culturas=culturas,
+            talhoes=talhoes,
+            regras=regras,
+            uf=uf,
+            municipio=municipio,
+            safra=safra,
+            objetivo="mercado",  # Força objetivo mercado
+            seed=seed,
+            geracoes=geracoes,
+            populacao=populacao
+        )
+        
+        return converter_tipos_python(resultado)
+        
+    except Exception as e:
+        import traceback
+        if DEBUG_ERRORS:
+            raise HTTPException(
+                status_code=500,
+                detail={
+                    "error": str(e),
+                    "traceback": traceback.format_exc()
+                }
+            )
+        else:
+            raise HTTPException(
+                status_code=500,
+                detail="Erro ao gerar otimização experimental de lucro de mercado."
+            )
+
 @app.post("/cache/limpar")
 def limpar_cache(request: Request):
     """Limpa o cache de resultados pesados (protegido por token)"""

package/backend-template/core/market_profit_comparator.py

@@ -0,0 +1,171 @@
+"""
+Avaliação Comparativa: Plano Sistema vs Avaliação com Lucro de Mercado
+
+Avalia o plano otimizado pelo sistema usando lucro de mercado normalizado.
+NÃO gera um novo plano otimizado por mercado - apenas avalia o plano atual.
+
+Bloqueia uso automático se houver itens críticos ou baixa confiabilidade.
+"""
+
+from typing import Dict, List, Optional
+from core.planner import gerar_plano_genetico
+from core.price_adapter import aplicar_precos_no_plano
+from core.market_profit_validator import validar_plano_lucro_mercado
+
+
+def comparar_plano_sistema_com_avaliacao_mercado(
+    culturas: List[Dict],
+    talhoes: List[Dict],
+    regras: List[Dict],
+    uf: Optional[str] = None,
+    municipio: Optional[str] = None,
+    safra: str = "2025/2026",
+    objetivo: str = "equilibrado",
+    seed: int = 42,
+    geracoes: int = 100,
+    populacao: int = 50
+) -> Dict:
+    """
+    Avalia o plano do sistema usando lucro de mercado para comparação.
+    
+    NÃO gera um plano otimizado por mercado. Apenas:
+    1. Gera plano normal com AG usando lucro do sistema
+    2. Avalia esse mesmo plano com lucro de mercado normalizado
+    3. Compara os dois valores de lucro
+    
+    Args:
+        culturas: Lista de culturas disponíveis
+        talhoes: Lista de talhões
+        regras: Regras de compatibilidade
+        uf: Unidade Federativa
+        municipio: Município
+        safra: Safra agrícola
+        objetivo: Objetivo de otimização
+        seed: Seed para reprodutibilidade
+        geracoes: Número de gerações do AG
+        populacao: Tamanho da população
+    
+    Returns:
+        Dict com modo, plano_sistema, avaliacao_mercado e comparacao
+    """
+    
+    # 1. Gerar plano principal normalmente
+    resultado = gerar_plano_genetico(
+        culturas=culturas,
+        talhoes=talhoes,
+        regras=regras,
+        objetivo=objetivo,
+        seed=seed,
+        geracoes=geracoes,
+        populacao=populacao
+    )
+    
+    # 2. Aplicar ZARC, se houver UF
+    if uf:
+        try:
+            from core.zarc_adapter import enriquecer_plano_com_zarc
+            resultado = enriquecer_plano_com_zarc(
+                resultado,
+                uf=uf,
+                municipio=municipio,
+                safra=safra
+            )
+        except Exception as zarc_error:
+            resultado["zarc_error"] = str(zarc_error)
+    
+    # 3. Aplicar preços
+    # IMPORTANTE: aplicar_precos_no_plano só aceita uf por enquanto
+    resultado = aplicar_precos_no_plano(resultado, uf=uf)
+    
+    # 4. Validar lucro de mercado
+    resultado = validar_plano_lucro_mercado(resultado)
+    
+    plano = resultado.get("plano", [])
+    
+    lucro_sistema_total = float(resultado.get("lucro_total", 0) or 0)
+    
+    lucro_mercado_total = 0.0
+    itens_mercado = []
+    
+    for item in plano:
+        lucro_mercado = item.get("lucro_mercado_estimado")
+        
+        if lucro_mercado is not None:
+            try:
+                lucro_mercado_float = float(lucro_mercado)
+                lucro_mercado_total += lucro_mercado_float
+            except Exception:
+                lucro_mercado_float = None
+        else:
+            lucro_mercado_float = None
+        
+        itens_mercado.append({
+            "talhao": item.get("talhao"),
+            "cultura": item.get("cultura"),
+            "lucro_sistema": item.get("lucro_estimado"),
+            "lucro_mercado_estimado": lucro_mercado_float,
+            "preco_real": item.get("preco_real"),
+            "preco_normalizado": item.get("preco_normalizado"),
+            "validacao_lucro_mercado": item.get("validacao_lucro_mercado")
+        })
+    
+    diferenca_absoluta = lucro_mercado_total - lucro_sistema_total
+    
+    if lucro_sistema_total != 0:
+        diferenca_percentual = (diferenca_absoluta / abs(lucro_sistema_total)) * 100
+    else:
+        diferenca_percentual = 0
+    
+    validacao = resultado.get("validacao_lucro_mercado", {}) or {}
+    
+    total = len(plano)
+    alta = int(validacao.get("itens_alta_confiabilidade", 0) or 0)
+    media = int(validacao.get("itens_media_confiabilidade", 0) or 0)
+    baixa = int(validacao.get("itens_baixa_confiabilidade", 0) or 0)
+    criticos = int(validacao.get("itens_criticos", 0) or 0)
+    
+    percentual_alta = (alta / total * 100) if total else 0
+    
+    pode_usar_mercado = (
+        criticos == 0
+        and baixa == 0
+        and percentual_alta >= 70
+    )
+    
+    motivo_bloqueio = None
+    if not pode_usar_mercado:
+        motivos = []
+        if criticos > 0:
+            motivos.append(f"{criticos} item(ns) crítico(s)")
+        if baixa > 0:
+            motivos.append(f"{baixa} item(ns) de baixa confiabilidade")
+        if percentual_alta < 70:
+            motivos.append(f"apenas {percentual_alta:.1f}% dos itens têm alta confiabilidade")
+        
+        motivo_bloqueio = (
+            "O lucro de mercado não deve ser usado como recomendação principal: "
+            + "; ".join(motivos)
+        )
+    
+    return {
+        "modo": "avaliacao_comparativa",
+        "descricao": "Avalia o plano principal usando lucro de mercado normalizado, sem substituir a recomendação oficial.",
+        "plano_sistema": resultado,
+        "avaliacao_mercado": {
+            "lucro_mercado_total": lucro_mercado_total,
+            "itens": itens_mercado
+        },
+        "comparacao": {
+            "lucro_sistema_total": lucro_sistema_total,
+            "lucro_mercado_total": lucro_mercado_total,
+            "diferenca_absoluta": diferenca_absoluta,
+            "diferenca_percentual": diferenca_percentual,
+            "itens_alta_confiabilidade": alta,
+            "itens_media_confiabilidade": media,
+            "itens_baixa_confiabilidade": baixa,
+            "itens_criticos": criticos,
+            "percentual_alta_confiabilidade": percentual_alta,
+            "pode_usar_mercado": pode_usar_mercado,
+            "motivo_bloqueio": motivo_bloqueio
+        }
+    }

package/backend-template/core/market_profit_optimizer.py

@@ -0,0 +1,158 @@
+"""
+Otimizador Experimental: Algoritmo Genético com Lucro de Mercado
+
+IMPORTANTE: Este é um modo EXPERIMENTAL que não substitui o plano principal.
+Usa lucro de mercado normalizado como fitness, mas bloqueia uso automático
+quando há itens críticos ou baixa confiabilidade.
+
+Status: EXPERIMENTAL - Requer validação manual antes de usar como recomendação.
+"""
+
+from typing import Dict, List, Optional
+from core.planner import gerar_plano_genetico
+from core.price_adapter import aplicar_precos_no_plano
+from core.market_profit_validator import validar_plano_lucro_mercado
+
+
+def gerar_plano_genetico_lucro_mercado_experimental(
+    culturas: List[Dict],
+    talhoes: List[Dict],
+    regras: List[Dict],
+    uf: Optional[str] = None,
+    municipio: Optional[str] = None,
+    safra: str = "2025/2026",
+    objetivo: str = "mercado",
+    seed: int = 42,
+    geracoes: int = 50,
+    populacao: int = 50
+) -> Dict:
+    """
+    Gera plano otimizado usando lucro de mercado como fitness (EXPERIMENTAL).
+    
+    ATENÇÃO: Este é um modo experimental que:
+    - Usa lucro_mercado_estimado como fitness principal
+    - Aplica penalidade forte para itens sem preço ou baixa confiabilidade
+    - Bloqueia uso automático se houver itens críticos
+    - NÃO substitui a recomendação principal do sistema
+    
+    Args:
+        culturas: Lista de culturas disponíveis
+        talhoes: Lista de talhões
+        regras: Regras de compatibilidade
+        uf: Unidade Federativa (necessário para preços regionais)
+        municipio: Município
+        safra: Safra agrícola
+        objetivo: Sempre "mercado" para este modo
+        seed: Seed para reprodutibilidade
+        geracoes: Número de gerações do AG
+        populacao: Tamanho da população
+    
+    Returns:
+        Dict com plano experimental, validação e status de bloqueio
+    """
+    
+    # Por enquanto, usar o AG normal com objetivo "lucro"
+    # TODO: Implementar fitness customizada baseada em lucro_mercado_estimado
+    resultado = gerar_plano_genetico(
+        culturas=culturas,
+        talhoes=talhoes,
+        regras=regras,
+        objetivo="lucro",  # Usar lucro como proxy por enquanto
+        seed=seed,
+        geracoes=geracoes,
+        populacao=populacao
+    )
+    
+    # Aplicar ZARC se houver UF
+    if uf:
+        try:
+            from core.zarc_adapter import enriquecer_plano_com_zarc
+            resultado = enriquecer_plano_com_zarc(
+                resultado,
+                uf=uf,
+                municipio=municipio,
+                safra=safra
+            )
+        except Exception as zarc_error:
+            resultado["zarc_error"] = str(zarc_error)
+    
+    # Aplicar preços e normalização
+    resultado = aplicar_precos_no_plano(resultado, uf=uf)
+    
+    # Validar lucro de mercado
+    resultado = validar_plano_lucro_mercado(resultado)
+    
+    # Calcular lucro de mercado total
+    lucro_mercado_total = 0.0
+    lucro_sistema_total = float(resultado.get("lucro_total", 0) or 0)
+    
+    for item in resultado['plano']:
+        lucro_mercado = item.get('lucro_mercado_estimado')
+        if lucro_mercado is not None:
+            try:
+                lucro_mercado_float = float(lucro_mercado)
+                lucro_mercado_total += lucro_mercado_float
+            except Exception:
+                pass
+    
+    # Calcular fitness de mercado (baseado no lucro de mercado)
+    # Normalizar para escala similar ao fitness do sistema
+    fitness_mercado = lucro_mercado_total / 1000000 if lucro_mercado_total > 0 else 0
+    fitness_sistema = float(resultado.get("fitness", 0) or 0)
+    
+    # Obter validação
+    validacao = resultado.get('validacao_lucro_mercado', {}) or {}
+    
+    # Determinar bloqueio
+    itens_criticos = int(validacao.get('itens_criticos', 0) or 0)
+    itens_baixa = int(validacao.get('itens_baixa_confiabilidade', 0) or 0)
+    percentual_alta = float(validacao.get('percentual_alta_confiabilidade', 0) or 0)
+    
+    bloqueado = (
+        itens_criticos > 0
+        or itens_baixa > 0
+        or percentual_alta < 70
+        or lucro_mercado_total <= 0
+    )
+    
+    # Montar motivo de bloqueio
+    motivo_bloqueio = None
+    if bloqueado:
+        motivos = []
+        if itens_criticos > 0:
+            motivos.append(f"{itens_criticos} item(ns) crítico(s)")
+        if itens_baixa > 0:
+            motivos.append(f"{itens_baixa} item(ns) de baixa confiabilidade")
+        if percentual_alta < 70:
+            motivos.append(f"apenas {percentual_alta:.1f}% dos itens têm alta confiabilidade")
+        if lucro_mercado_total <= 0:
+            motivos.append("lucro de mercado total não é positivo")
+        
+        motivo_bloqueio = (
+            "Este plano experimental não deve ser usado como recomendação principal: "
+            + "; ".join(motivos)
+        )
+    
+    # Montar resposta experimental
+    return {
+        "modo": "otimizacao_mercado_experimental",
+        "experimental": True,
+        "aviso": "Este plano é experimental e não substitui a recomendação principal. Validar manualmente antes de usar.",
+        "plano": resultado['plano'],
+        "lucro_mercado_total": float(lucro_mercado_total),
+        "lucro_sistema_total_referencial": float(lucro_sistema_total),
+        "fitness_mercado": float(fitness_mercado),
+        "fitness_sistema_referencial": float(fitness_sistema),
+        "risco_medio": float(resultado.get("risco_medio", 0) or 0),
+        "diversidade": int(resultado.get("diversidade", 0) or 0),
+        "area_total": float(resultado.get("area_total", 0) or 0),
+        "geracoes": int(geracoes),
+        "objetivo": "mercado",
+        "seed": int(seed),
+        "validacao_lucro_mercado": validacao,
+        "bloqueado": bloqueado,
+        "pode_usar_como_recomendacao": not bloqueado,
+        "motivo_bloqueio": motivo_bloqueio,
+        "zarc": resultado.get("zarc"),
+        "precos": resultado.get("precos")
+    }

package/package.json

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