agroplan-ai-cli 1.0.32 → 1.0.34

package/backend-template/VERSION.json

@@ -1,6 +1,6 @@
 {
-  "cli_version": "1.0.32",
-  "backend_template_version": "1.0.32",
+  "cli_version": "1.0.34",
+  "backend_template_version": "1.0.34",
   "zarc_index_version": "2025-2026-fast-index-v2",
   "price_index_version": "2025-05-reference-v1",
   "features": [
@@ -21,7 +21,9 @@
     "smart_crop_calendar_engine",
     "manual_field_registration",
     "crop_calendar_from_manual_field",
-    "expanded_crop_calendar_10_cultures"
+    "expanded_crop_calendar_10_cultures",
+    "calendar_date_safety",
+    "calendar_weather_integration"
   ],
-  "generated_at": "2026-05-10T18:30:00Z"
+  "generated_at": "2026-05-10T21:00:00Z"
 }

package/backend-template/api.py

@@ -1358,6 +1358,16 @@ def gerar_calendario(request: dict):
             zarc_context=request.get("zarc_context")
         )
         
+        # Enriquecer com clima se solicitado
+        usar_clima = request.get("usar_clima", False)
+        if usar_clima:
+            from core.calendar_weather_adapter import enriquecer_calendario_com_clima
+            lat = field_data.get("lat")
+            lon = field_data.get("lon")
+            resultado = enriquecer_calendario_com_clima(resultado, lat=lat, lon=lon)
+        else:
+            resultado["weather_enabled"] = False
+        
         return converter_tipos_python(resultado)
         
     except HTTPException:
@@ -1532,6 +1542,7 @@ def gerar_calendario_talhao(field_id: str, request: dict):
     try:
         from core.field_storage import obter_talhao_usuario
         from core.crop_calendar_engine import gerar_calendario_cultura
+        from core.calendar_weather_adapter import enriquecer_calendario_com_clima
         from core.planning_models import Field, SoilType, Slope, WaterAvailability, GenerateCalendarRequest
         from datetime import datetime
         
@@ -1575,6 +1586,15 @@ def gerar_calendario_talhao(field_id: str, request: dict):
             crop_plan_id=None
         )
         
+        # Enriquecer com clima se solicitado
+        usar_clima = request.get("usar_clima", False)
+        if usar_clima:
+            lat = field_data.get("lat")
+            lon = field_data.get("lon")
+            resultado = enriquecer_calendario_com_clima(resultado, lat=lat, lon=lon)
+        else:
+            resultado["weather_enabled"] = False
+        
         # Adicionar dados do talhão na resposta
         resultado["field_data"] = field_data
         

package/backend-template/core/calendar_weather_adapter.py

@@ -0,0 +1,176 @@
+"""
+Adaptador de Clima para Calendário Agrícola
+
+Enriquece tarefas do calendário com contexto climático:
+- Previsão real (0-16 dias)
+- Climatologia (17+ dias)
+- Recomendações situacionais
+"""
+
+from datetime import date, timedelta
+from typing import Dict, List, Optional
+from providers.calendar_weather_provider import (
+    buscar_previsao_curto_prazo,
+    buscar_climatologia_longo_prazo,
+    gerar_recomendacao_climatica
+)
+
+
+def enriquecer_calendario_com_clima(
+    calendar: Dict,
+    lat: Optional[float] = None,
+    lon: Optional[float] = None
+) -> Dict:
+    """
+    Enriquece calendário com contexto climático.
+    
+    Args:
+        calendar: Calendário gerado
+        lat: Latitude do talhão
+        lon: Longitude do talhão
+    
+    Returns:
+        Calendário enriquecido com weather_context em cada tarefa
+    """
+    
+    # Verificar se coordenadas foram fornecidas
+    if lat is None or lon is None:
+        calendar["weather_enabled"] = False
+        calendar["weather_warnings"] = [
+            "Para usar clima integrado, informe latitude e longitude do talhão."
+        ]
+        return calendar
+    
+    try:
+        today = date.today()
+        planting_date = date.fromisoformat(calendar["planting_date"])
+        estimated_harvest = date.fromisoformat(calendar["estimated_harvest_date"])
+        
+        # Buscar previsão de curto prazo (0-16 dias)
+        forecast_end = today + timedelta(days=16)
+        forecast_data = buscar_previsao_curto_prazo(lat, lon, today, days=16)
+        
+        # Criar mapa de previsão por data
+        forecast_map = {item["date"]: item for item in forecast_data}
+        
+        # Buscar climatologia de longo prazo (17+ dias até colheita)
+        climatology_data = []
+        if estimated_harvest > forecast_end:
+            climatology_start = forecast_end + timedelta(days=1)
+            climatology_data = buscar_climatologia_longo_prazo(
+                lat, lon, climatology_start, estimated_harvest
+            )
+        
+        # Criar mapa de climatologia por data
+        climatology_map = {item["date"]: item for item in climatology_data}
+        
+        # Contadores
+        forecast_tasks = 0
+        climatology_tasks = 0
+        no_weather_tasks = 0
+        sources_used = set()
+        
+        # Enriquecer cada tarefa
+        for task in calendar.get("tasks", []):
+            task_date_str = task["date"]
+            task_date = date.fromisoformat(task_date_str)
+            
+            # Apenas enriquecer tarefas sensíveis ao clima
+            if not task.get("weather_sensitive", False):
+                task["weather_context"] = {
+                    "active": False,
+                    "reason": "Tarefa não sensível ao clima"
+                }
+                no_weather_tasks += 1
+                continue
+            
+            # Verificar se está no passado
+            if task_date < today:
+                task["weather_context"] = {
+                    "active": False,
+                    "reason": "Tarefa no passado"
+                }
+                no_weather_tasks += 1
+                continue
+            
+            # Tentar usar previsão real (0-16 dias)
+            if task_date_str in forecast_map:
+                weather_data = forecast_map[task_date_str]
+                forecast_tasks += 1
+                sources_used.add("open-meteo")
+            # Usar climatologia (17+ dias)
+            elif task_date_str in climatology_map:
+                weather_data = climatology_map[task_date_str]
+                climatology_tasks += 1
+                sources_used.add(weather_data["source"])
+            else:
+                # Sem dados disponíveis
+                task["weather_context"] = {
+                    "active": False,
+                    "reason": "Dados climáticos não disponíveis para esta data"
+                }
+                no_weather_tasks += 1
+                continue
+            
+            # Gerar recomendação
+            recommendation = gerar_recomendacao_climatica(
+                task.get("type", ""),
+                task.get("title", ""),
+                weather_data
+            )
+            
+            # Gerar resumo
+            forecast_type = weather_data.get("forecast_type", "climatology")
+            if forecast_type == "forecast":
+                summary = f"Previsão: {weather_data.get('precipitation_sum', 0):.1f}mm de chuva, {weather_data.get('temperature_min', 0):.0f}°C a {weather_data.get('temperature_max', 0):.0f}°C"
+            else:
+                summary = f"Climatologia: {weather_data.get('precipitation_expected', 'Condições típicas')}"
+            
+            # Adicionar contexto climático à tarefa
+            task["weather_context"] = {
+                "active": True,
+                "source": weather_data.get("source", "unknown"),
+                "forecast_type": forecast_type,
+                "summary": summary,
+                "precipitation_mm": weather_data.get("precipitation_sum") or weather_data.get("precipitation_mm_avg"),
+                "precipitation_probability": weather_data.get("precipitation_probability"),
+                "temperature_min": weather_data.get("temperature_min"),
+                "temperature_max": weather_data.get("temperature_max"),
+                "recommendation": recommendation,
+                "confidence": weather_data.get("confidence", "media")
+            }
+        
+        # Adicionar resumo geral
+        calendar["weather_enabled"] = True
+        calendar["weather_summary"] = {
+            "forecast_tasks": forecast_tasks,
+            "climatology_tasks": climatology_tasks,
+            "no_weather_tasks": no_weather_tasks,
+            "sources": list(sources_used)
+        }
+        
+        # Adicionar avisos
+        weather_warnings = []
+        
+        if climatology_tasks > 0:
+            weather_warnings.append(
+                f"{climatology_tasks} tarefa(s) usam climatologia/histórico (17+ dias). "
+                "Não é previsão exata, apenas condições típicas do período."
+            )
+        
+        if forecast_tasks > 0:
+            weather_warnings.append(
+                f"{forecast_tasks} tarefa(s) usam previsão meteorológica real (0-16 dias)."
+            )
+        
+        calendar["weather_warnings"] = weather_warnings
+        
+        return calendar
+        
+    except Exception as e:
+        print(f"Erro ao enriquecer calendário com clima: {e}")
+        calendar["weather_enabled"] = False
+        calendar["weather_warnings"] = [
+            f"Erro ao buscar dados climáticos: {str(e)}"
+        ]
+        return calendar

package/backend-template/core/crop_calendar_engine.py

@@ -875,6 +875,48 @@ def gerar_calendario_cultura(
     # Ordenar tarefas por data
     tasks.sort(key=lambda t: t.date)
     
+    # Detectar e ajustar tarefas no passado
+    today = date.today()
+    adjusted_tasks_count = 0
+    calendar_warnings = []
+    
+    for task in tasks:
+        if task.date < today:
+            # Marcar tarefa como ajustada
+            task.original_date = task.date
+            task.date = today
+            task.adjusted = True
+            
+            # Aumentar prioridade se não for crítica
+            if task.priority != TaskPriority.CRITICAL:
+                task.priority = TaskPriority.HIGH
+            
+            # Adicionar observação à descrição
+            task.description += f" [AJUSTADA: Data original era {task.original_date.isoformat()}, mas já passou. Tarefa reagendada para hoje.]"
+            
+            adjusted_tasks_count += 1
+    
+    # Adicionar avisos se houver tarefas ajustadas
+    if adjusted_tasks_count > 0:
+        calendar_warnings.append(
+            f"{adjusted_tasks_count} tarefa(s) foram ajustadas porque a data original já havia passado. "
+            "Considere escolher uma data de plantio mais distante no futuro."
+        )
+    
+    # Verificar se data de plantio está muito próxima
+    days_until_planting = (planting_date - today).days
+    if days_until_planting <= 7 and days_until_planting >= 0:
+        calendar_warnings.append(
+            f"Sua data de plantio está em {days_until_planting} dia(s). "
+            "Tarefas preparatórias podem ter sido ajustadas. "
+            "Recomendamos planejar com pelo menos 2 semanas de antecedência."
+        )
+    elif days_until_planting < 0:
+        calendar_warnings.append(
+            "A data de plantio escolhida já passou. "
+            "O calendário foi ajustado, mas recomendamos escolher uma data futura."
+        )
+    
     # Montar resposta
     return {
         "cultura": cultura,
@@ -906,6 +948,9 @@ def gerar_calendario_cultura(
         "total_tasks": len(tasks),
         "weather_sensitive_tasks": sum(1 for task in tasks if task.weather_sensitive),
         "critical_tasks": sum(1 for task in tasks if task.priority == TaskPriority.CRITICAL),
+        "has_adjusted_tasks": adjusted_tasks_count > 0,
+        "adjusted_tasks_count": adjusted_tasks_count,
+        "calendar_warnings": calendar_warnings,
         "cautela": "Este calendário é uma base inicial de planejamento. As datas e tarefas devem ser ajustadas conforme clima, solo, cultivar, manejo e orientação técnica."
     }
 

package/backend-template/core/planning_models.py

@@ -259,9 +259,11 @@ class CalendarTask:
     status: TaskStatus = TaskStatus.PENDING
     weather_sensitive: bool = False
     completed_at: Optional[datetime] = None
+    adjusted: bool = False  # Se a tarefa foi ajustada por estar no passado
+    original_date: Optional[date] = None  # Data original antes do ajuste
 
     def to_dict(self) -> Dict:
-        return {
+        result = {
             "id": self.id,
             "crop_plan_id": self.crop_plan_id,
             "date": self.date.isoformat(),
@@ -272,8 +274,14 @@ class CalendarTask:
             "source": self.source,
             "status": self.status.value,
             "weather_sensitive": self.weather_sensitive,
-            "completed_at": self.completed_at.isoformat() if self.completed_at else None
+            "completed_at": self.completed_at.isoformat() if self.completed_at else None,
+            "adjusted": self.adjusted
         }
+        
+        if self.original_date:
+            result["original_date"] = self.original_date.isoformat()
+        
+        return result
 
 
 @dataclass

package/backend-template/providers/calendar_weather_provider.py

@@ -0,0 +1,272 @@
+"""
+Provider de Clima para Calendário Agrícola
+
+Estratégia honesta sobre previsão climática:
+- 0-16 dias: Previsão meteorológica real (Open-Meteo)
+- 17+ dias: Climatologia/histórico (NASA POWER ou fallback local)
+
+Não fingimos ter previsão exata para ciclos longos (120+ dias).
+"""
+
+from datetime import date, timedelta
+from typing import Dict, List, Optional
+import requests
+from .cache import get_cache, set_cache
+
+
+def buscar_previsao_curto_prazo(
+    lat: float,
+    lon: float,
+    start_date: date,
+    days: int = 16
+) -> List[Dict]:
+    """
+    Busca previsão meteorológica real para os próximos 16 dias.
+    
+    Usa Open-Meteo Forecast API.
+    
+    Args:
+        lat: Latitude
+        lon: Longitude
+        start_date: Data inicial
+        days: Número de dias (máximo 16)
+    
+    Returns:
+        Lista de dicionários com previsão por data
+    """
+    
+    # Limitar a 16 dias (limite confiável do Open-Meteo)
+    days = min(days, 16)
+    
+    # Cache key
+    cache_key = f"calendar_forecast:{lat}:{lon}:{start_date.isoformat()}:{days}"
+    cached = get_cache(cache_key)
+    if cached:
+        return cached
+    
+    try:
+        # Open-Meteo Forecast API
+        url = "https://api.open-meteo.com/v1/forecast"
+        params = {
+            "latitude": lat,
+            "longitude": lon,
+            "daily": "temperature_2m_max,temperature_2m_min,precipitation_sum,precipitation_probability_max",
+            "timezone": "auto",
+            "forecast_days": days
+        }
+        
+        response = requests.get(url, params=params, timeout=10)
+        response.raise_for_status()
+        data = response.json()
+        
+        # Processar resposta
+        daily = data.get("daily", {})
+        dates = daily.get("time", [])
+        temp_max = daily.get("temperature_2m_max", [])
+        temp_min = daily.get("temperature_2m_min", [])
+        precip_sum = daily.get("precipitation_sum", [])
+        precip_prob = daily.get("precipitation_probability_max", [])
+        
+        result = []
+        for i, date_str in enumerate(dates):
+            result.append({
+                "date": date_str,
+                "source": "open-meteo",
+                "forecast_type": "forecast",
+                "temperature_max": temp_max[i] if i < len(temp_max) else None,
+                "temperature_min": temp_min[i] if i < len(temp_min) else None,
+                "precipitation_sum": precip_sum[i] if i < len(precip_sum) else None,
+                "precipitation_probability": precip_prob[i] if i < len(precip_prob) else None,
+                "confidence": "alta"
+            })
+        
+        # Cache por 6 horas
+        set_cache(cache_key, result, ttl_seconds=21600)
+        
+        return result
+        
+    except Exception as e:
+        print(f"Erro ao buscar previsão Open-Meteo: {e}")
+        return []
+
+
+def buscar_climatologia_longo_prazo(
+    lat: float,
+    lon: float,
+    start_date: date,
+    end_date: date
+) -> List[Dict]:
+    """
+    Busca climatologia/histórico para períodos longos (17+ dias).
+    
+    Inicialmente usa fallback local mensal.
+    Futuramente pode integrar NASA POWER.
+    
+    Args:
+        lat: Latitude
+        lon: Longitude
+        start_date: Data inicial
+        end_date: Data final
+    
+    Returns:
+        Lista de dicionários com climatologia por data/mês
+    """
+    
+    # Por enquanto, usar fallback local baseado em médias mensais
+    # Futuramente: integrar NASA POWER Climatology API
+    
+    result = []
+    current = start_date
+    
+    while current <= end_date:
+        month = current.month
+        
+        # Climatologia simplificada por mês (Brasil)
+        climatology = _get_monthly_climatology(month, lat, lon)
+        
+        result.append({
+            "date": current.isoformat(),
+            "source": "climate-fallback",
+            "forecast_type": "climatology",
+            "temperature_max": climatology["temp_max"],
+            "temperature_min": climatology["temp_min"],
+            "precipitation_expected": climatology["precip_desc"],
+            "precipitation_mm_avg": climatology["precip_mm"],
+            "confidence": "media"
+        })
+        
+        current += timedelta(days=1)
+    
+    return result
+
+
+def _get_monthly_climatology(month: int, lat: float, lon: float) -> Dict:
+    """
+    Retorna climatologia simplificada por mês.
+    
+    Baseado em médias históricas do Brasil.
+    Futuramente: usar NASA POWER ou dados regionais.
+    """
+    
+    # Determinar região aproximada (simplificado)
+    if lat < -23:  # Sul
+        region = "sul"
+    elif lat < -15:  # Sudeste/Centro-Oeste
+        region = "sudeste"
+    else:  # Norte/Nordeste
+        region = "norte"
+    
+    # Climatologia simplificada (valores aproximados)
+    climatology_data = {
+        "sul": {
+            1: {"temp_max": 28, "temp_min": 18, "precip_mm": 150, "precip_desc": "Chuvas frequentes"},
+            2: {"temp_max": 28, "temp_min": 18, "precip_mm": 140, "precip_desc": "Chuvas frequentes"},
+            3: {"temp_max": 26, "temp_min": 16, "precip_mm": 120, "precip_desc": "Chuvas moderadas"},
+            4: {"temp_max": 23, "temp_min": 13, "precip_mm": 100, "precip_desc": "Chuvas moderadas"},
+            5: {"temp_max": 20, "temp_min": 10, "precip_mm": 90, "precip_desc": "Chuvas ocasionais"},
+            6: {"temp_max": 18, "temp_min": 8, "precip_mm": 80, "precip_desc": "Chuvas ocasionais"},
+            7: {"temp_max": 18, "temp_min": 8, "precip_mm": 70, "precip_desc": "Período seco"},
+            8: {"temp_max": 20, "temp_min": 10, "precip_mm": 80, "precip_desc": "Período seco"},
+            9: {"temp_max": 22, "temp_min": 12, "precip_mm": 110, "precip_desc": "Chuvas aumentando"},
+            10: {"temp_max": 24, "temp_min": 14, "precip_mm": 130, "precip_desc": "Chuvas frequentes"},
+            11: {"temp_max": 26, "temp_min": 16, "precip_mm": 120, "precip_desc": "Chuvas frequentes"},
+            12: {"temp_max": 28, "temp_min": 18, "precip_mm": 140, "precip_desc": "Chuvas frequentes"},
+        },
+        "sudeste": {
+            1: {"temp_max": 30, "temp_min": 20, "precip_mm": 220, "precip_desc": "Estação chuvosa"},
+            2: {"temp_max": 30, "temp_min": 20, "precip_mm": 200, "precip_desc": "Estação chuvosa"},
+            3: {"temp_max": 29, "temp_min": 19, "precip_mm": 160, "precip_desc": "Chuvas frequentes"},
+            4: {"temp_max": 27, "temp_min": 17, "precip_mm": 80, "precip_desc": "Chuvas diminuindo"},
+            5: {"temp_max": 25, "temp_min": 15, "precip_mm": 50, "precip_desc": "Período seco"},
+            6: {"temp_max": 24, "temp_min": 13, "precip_mm": 40, "precip_desc": "Período seco"},
+            7: {"temp_max": 24, "temp_min": 13, "precip_mm": 30, "precip_desc": "Período seco"},
+            8: {"temp_max": 26, "temp_min": 15, "precip_mm": 40, "precip_desc": "Período seco"},
+            9: {"temp_max": 27, "temp_min": 16, "precip_mm": 70, "precip_desc": "Chuvas aumentando"},
+            10: {"temp_max": 28, "temp_min": 18, "precip_mm": 130, "precip_desc": "Chuvas frequentes"},
+            11: {"temp_max": 29, "temp_min": 19, "precip_mm": 170, "precip_desc": "Chuvas frequentes"},
+            12: {"temp_max": 29, "temp_min": 20, "precip_mm": 200, "precip_desc": "Estação chuvosa"},
+        },
+        "norte": {
+            1: {"temp_max": 31, "temp_min": 23, "precip_mm": 280, "precip_desc": "Estação chuvosa"},
+            2: {"temp_max": 31, "temp_min": 23, "precip_mm": 300, "precip_desc": "Estação chuvosa"},
+            3: {"temp_max": 31, "temp_min": 23, "precip_mm": 320, "precip_desc": "Estação chuvosa"},
+            4: {"temp_max": 31, "temp_min": 23, "precip_mm": 280, "precip_desc": "Chuvas frequentes"},
+            5: {"temp_max": 31, "temp_min": 23, "precip_mm": 200, "precip_desc": "Chuvas moderadas"},
+            6: {"temp_max": 32, "temp_min": 23, "precip_mm": 100, "precip_desc": "Chuvas ocasionais"},
+            7: {"temp_max": 33, "temp_min": 23, "precip_mm": 60, "precip_desc": "Período seco"},
+            8: {"temp_max": 34, "temp_min": 24, "precip_mm": 50, "precip_desc": "Período seco"},
+            9: {"temp_max": 34, "temp_min": 24, "precip_mm": 80, "precip_desc": "Chuvas aumentando"},
+            10: {"temp_max": 33, "temp_min": 24, "precip_mm": 130, "precip_desc": "Chuvas aumentando"},
+            11: {"temp_max": 32, "temp_min": 23, "precip_mm": 180, "precip_desc": "Chuvas frequentes"},
+            12: {"temp_max": 31, "temp_min": 23, "precip_mm": 250, "precip_desc": "Estação chuvosa"},
+        }
+    }
+    
+    return climatology_data.get(region, climatology_data["sudeste"]).get(month, {
+        "temp_max": 28,
+        "temp_min": 18,
+        "precip_mm": 100,
+        "precip_desc": "Chuvas moderadas"
+    })
+
+
+def gerar_recomendacao_climatica(
+    task_type: str,
+    task_title: str,
+    weather_data: Dict
+) -> str:
+    """
+    Gera recomendação baseada no contexto climático.
+    
+    Args:
+        task_type: Tipo da tarefa (irrigate, plant, etc)
+        task_title: Título da tarefa
+        weather_data: Dados climáticos
+    
+    Returns:
+        Recomendação textual
+    """
+    
+    forecast_type = weather_data.get("forecast_type", "climatology")
+    precip = weather_data.get("precipitation_sum") or weather_data.get("precipitation_mm_avg", 0)
+    precip_prob = weather_data.get("precipitation_probability", 0)
+    temp_max = weather_data.get("temperature_max", 25)
+    temp_min = weather_data.get("temperature_min", 15)
+    
+    # Recomendações para irrigação
+    if "irrigar" in task_title.lower() or task_type == "irrigate":
+        if forecast_type == "forecast":
+            if precip >= 8:
+                return f"Chuva prevista suficiente ({precip:.1f}mm). Verifique o solo antes de irrigar."
+            elif precip >= 3:
+                return f"Chuva moderada prevista ({precip:.1f}mm). Irrigação pode ser parcial."
+            else:
+                return f"Pouca chuva prevista ({precip:.1f}mm). Irrigação provavelmente necessária."
+        else:
+            return f"Climatologia: {weather_data.get('precipitation_expected', 'Chuvas moderadas')}. Monitore o solo."
+    
+    # Recomendações para plantio
+    if "plantar" in task_title.lower() or task_type == "plant":
+        if forecast_type == "forecast":
+            if precip > 50:
+                return f"Chuva elevada prevista ({precip:.1f}mm). Avalie adiar o plantio para evitar solo encharcado."
+            elif precip < 5 and precip_prob < 30:
+                return f"Tempo seco previsto. Bom para plantio, mas prepare irrigação."
+            else:
+                return f"Condições adequadas para plantio. Chuva moderada prevista ({precip:.1f}mm)."
+        else:
+            return f"Climatologia: {weather_data.get('precipitation_expected', 'Chuvas moderadas')}. Planeje conforme histórico."
+    
+    # Recomendações para temperatura
+    if temp_max > 35:
+        return f"Calor elevado previsto ({temp_max:.1f}°C). Monitorar estresse hídrico da cultura."
+    elif temp_min < 5:
+        return f"Frio intenso previsto ({temp_min:.1f}°C). Avaliar risco para a cultura."
+    elif temp_min < 10:
+        return f"Temperatura baixa prevista ({temp_min:.1f}°C). Monitorar desenvolvimento da cultura."
+    
+    # Recomendação genérica
+    if forecast_type == "forecast":
+        return f"Temperatura: {temp_min:.1f}°C a {temp_max:.1f}°C. Chuva: {precip:.1f}mm."
+    else:
+        return f"Climatologia: {weather_data.get('precipitation_expected', 'Condições típicas do período')}."

package/package.json

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