agroplan-ai-cli 1.0.6 → 1.0.8

package/backend-template/.env.example

@@ -12,8 +12,13 @@ CORS_ORIGINS=http://localhost:3000,http://127.0.0.1:3000
 
 # Data Mode
 # simulated: Uses CSV files with simulated data
-# real: Uses real APIs (future implementation)
-DATA_MODE=simulated
+# real: Uses real APIs only
+# hybrid: Uses real APIs with fallback to simulated data
+DATA_MODE=hybrid
+
+# Weather Provider Configuration
+WEATHER_PROVIDER=open-meteo
+PROVIDER_CACHE_TTL=3600
 
 # Cache Administration (optional)
 # If set, /cache/limpar endpoint requires X-Cache-Token header

package/backend-template/api.py

@@ -2,7 +2,7 @@
 FastAPI Backend para AgroPlan AI
 """
 
-from fastapi import FastAPI, HTTPException, Request
+from fastapi import FastAPI, HTTPException, Request, Query
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 from typing import Optional
@@ -17,10 +17,17 @@ from core.planner import gerar_cenarios, gerar_plano_genetico
 from core.bruteforce_validator import comparar_ag_com_forca_bruta, executar_multiplas_rodadas
 from core.report_generator import gerar_relatorio_completo
 
+# Importar provedores de dados reais
+from providers.weather_provider import get_weather_summary
+from providers.cache import clear_provider_cache, get_cache_stats
+
 # Configurações de ambiente
 HOST = os.getenv("HOST", "0.0.0.0")
 PORT = int(os.getenv("PORT", "8000"))
 CORS_ORIGINS = os.getenv("CORS_ORIGINS", "http://localhost:3000,http://127.0.0.1:3000").split(",")
+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"))
 
 # Cache em memória para resultados pesados
 _resultados_cache = {}
@@ -126,16 +133,53 @@ def health():
     """Verifica saúde da API"""
     try:
         culturas, talhoes, regras = get_dados()
+        provider_cache_stats = get_cache_stats()
+        
         return {
             "status": "healthy",
             "culturas": len(culturas),
             "talhoes": len(talhoes),
             "regras": len(regras),
-            "cache_items": len(_resultados_cache)
+            "cache_items": len(_resultados_cache),
+            "data_mode": DATA_MODE,
+            "providers": {
+                "weather": "available" if WEATHER_PROVIDER else "disabled"
+            },
+            "provider_cache": provider_cache_stats
         }
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+@app.get("/dados/clima")
+def get_clima(
+    lat: Optional[float] = Query(None, description="Latitude"),
+    lon: Optional[float] = Query(None, description="Longitude"), 
+    days: int = Query(30, description="Número de dias para análise")
+):
+    """Obtém dados climáticos reais ou simulados"""
+    try:
+        # Se lat ou lon não foram fornecidos, retornar mensagem amigável
+        if lat is None or lon is None:
+            return {
+                "message": "Informe latitude e longitude para consultar dados climáticos reais.",
+                "exemplo_sao_paulo": "/dados/clima?lat=-23.55&lon=-46.63&days=30",
+                "exemplo_brasilia": "/dados/clima?lat=-15.78&lon=-47.93&days=30",
+                "parametros": {
+                    "lat": "Latitude da localização",
+                    "lon": "Longitude da localização", 
+                    "days": "Número de dias analisados, padrão 30"
+                }
+            }
+        
+        if days < 1 or days > 365:
+            raise HTTPException(status_code=400, detail="Days deve estar entre 1 e 365")
+        
+        weather_data = get_weather_summary(lat, lon, days)
+        return weather_data.to_dict()
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
 @app.get("/dashboard")
 def get_dashboard():
     """Retorna resumo do dashboard"""

package/backend-template/providers/__init__.py

@@ -0,0 +1 @@
+# Provedores de dados reais para AgroPlan AI

package/backend-template/providers/cache.py

@@ -0,0 +1,49 @@
+"""
+Cache simples em memória para chamadas de APIs externas
+"""
+import time
+from typing import Any, Optional
+
+# Cache global em memória
+_cache = {}
+
+def get_cache(key: str) -> Optional[Any]:
+    """Recupera valor do cache se ainda válido"""
+    if key not in _cache:
+        return None
+    
+    value, expiry = _cache[key]
+    if time.time() > expiry:
+        # Cache expirado, remove
+        del _cache[key]
+        return None
+    
+    return value
+
+def set_cache(key: str, value: Any, ttl_seconds: int = 3600) -> None:
+    """Armazena valor no cache com TTL"""
+    expiry = time.time() + ttl_seconds
+    _cache[key] = (value, expiry)
+
+def clear_provider_cache() -> None:
+    """Limpa todo o cache de provedores"""
+    global _cache
+    _cache = {}
+
+def get_cache_stats() -> dict:
+    """Retorna estatísticas do cache"""
+    current_time = time.time()
+    valid_items = 0
+    expired_items = 0
+    
+    for key, (value, expiry) in _cache.items():
+        if current_time <= expiry:
+            valid_items += 1
+        else:
+            expired_items += 1
+    
+    return {
+        "total_items": len(_cache),
+        "valid_items": valid_items,
+        "expired_items": expired_items
+    }

package/backend-template/providers/types.py

@@ -0,0 +1,40 @@
+"""
+Tipos de dados para provedores externos
+"""
+from typing import Optional
+from dataclasses import dataclass
+
+@dataclass
+class WeatherSummary:
+    """Resumo de dados climáticos"""
+    source: str
+    latitude: float
+    longitude: float
+    temperatura_media: Optional[float] = None
+    temperatura_maxima: Optional[float] = None
+    temperatura_minima: Optional[float] = None
+    precipitacao_total: Optional[float] = None
+    evapotranspiracao: Optional[float] = None
+    umidade_media: Optional[float] = None
+    radiacao_solar: Optional[float] = None
+    risco_climatico_estimado: str = "indeterminado"
+    fallback: bool = False
+    error: Optional[str] = None
+    
+    def to_dict(self) -> dict:
+        """Converte para dicionário para JSON"""
+        return {
+            "source": self.source,
+            "latitude": self.latitude,
+            "longitude": self.longitude,
+            "temperatura_media": self.temperatura_media,
+            "temperatura_maxima": self.temperatura_maxima,
+            "temperatura_minima": self.temperatura_minima,
+            "precipitacao_total": self.precipitacao_total,
+            "evapotranspiracao": self.evapotranspiracao,
+            "umidade_media": self.umidade_media,
+            "radiacao_solar": self.radiacao_solar,
+            "risco_climatico_estimado": self.risco_climatico_estimado,
+            "fallback": self.fallback,
+            "error": self.error
+        }

package/backend-template/providers/weather_provider.py

@@ -0,0 +1,161 @@
+"""
+Provedor de dados climáticos usando Open-Meteo
+"""
+import urllib.request
+import urllib.parse
+import json
+from datetime import datetime, timedelta
+from typing import Optional
+from .types import WeatherSummary
+from .cache import get_cache, set_cache
+
+def estimar_risco_climatico(temp_media: Optional[float], precipitacao_total: Optional[float]) -> str:
+    """Estima risco climático baseado em temperatura e precipitação"""
+    if temp_media is None or precipitacao_total is None:
+        return "indeterminado"
+    
+    # Heurística simples inicial
+    if precipitacao_total < 30:
+        return "alto"
+    if temp_media > 34:
+        return "alto"
+    if precipitacao_total < 70:
+        return "medio"
+    return "baixo"
+
+def get_weather_summary(lat: float, lon: float, days: int = 30) -> WeatherSummary:
+    """
+    Obtém resumo climático usando Open-Meteo
+    
+    Args:
+        lat: Latitude
+        lon: Longitude  
+        days: Número de dias para análise (padrão 30)
+    
+    Returns:
+        WeatherSummary com dados climáticos ou fallback
+    """
+    
+    # Chave do cache
+    cache_key = f"weather_{lat}_{lon}_{days}"
+    
+    # Verificar cache primeiro
+    cached = get_cache(cache_key)
+    if cached:
+        return WeatherSummary(**cached)
+    
+    try:
+        # Calcular datas (últimos N dias)
+        end_date = datetime.now().date()
+        start_date = end_date - timedelta(days=days)
+        
+        # Parâmetros da API Open-Meteo Archive
+        params = {
+            "latitude": str(lat),
+            "longitude": str(lon),
+            "start_date": start_date.strftime("%Y-%m-%d"),
+            "end_date": end_date.strftime("%Y-%m-%d"),
+            "daily": ",".join([
+                "temperature_2m_mean",
+                "temperature_2m_max", 
+                "temperature_2m_min",
+                "precipitation_sum",
+                "et0_fao_evapotranspiration",
+                "relative_humidity_2m_mean",
+                "shortwave_radiation_sum"
+            ]),
+            "timezone": "America/Sao_Paulo"
+        }
+        
+        # Construir URL
+        base_url = "https://archive-api.open-meteo.com/v1/archive"
+        query_string = urllib.parse.urlencode(params)
+        url = f"{base_url}?{query_string}"
+        
+        # Fazer requisição
+        with urllib.request.urlopen(url, timeout=10) as response:
+            data = json.loads(response.read().decode())
+        
+        daily = data.get("daily", {})
+        
+        # Extrair dados
+        temps_mean = daily.get("temperature_2m_mean", [])
+        temps_max = daily.get("temperature_2m_max", [])
+        temps_min = daily.get("temperature_2m_min", [])
+        precipitation = daily.get("precipitation_sum", [])
+        evapotranspiration = daily.get("et0_fao_evapotranspiration", [])
+        humidity = daily.get("relative_humidity_2m_mean", [])
+        radiation = daily.get("shortwave_radiation_sum", [])
+        
+        # Calcular médias (ignorando valores None)
+        def safe_mean(values):
+            valid_values = [v for v in values if v is not None]
+            return sum(valid_values) / len(valid_values) if valid_values else None
+        
+        def safe_sum(values):
+            valid_values = [v for v in values if v is not None]
+            return sum(valid_values) if valid_values else None
+        
+        temp_media = safe_mean(temps_mean)
+        temp_maxima = safe_mean(temps_max)
+        temp_minima = safe_mean(temps_min)
+        precip_total = safe_sum(precipitation)
+        evap_media = safe_mean(evapotranspiration)
+        umid_media = safe_mean(humidity)
+        rad_total = safe_sum(radiation)
+        
+        # Estimar risco climático
+        risco = estimar_risco_climatico(temp_media, precip_total)
+        
+        # Criar resultado
+        result = WeatherSummary(
+            source="open-meteo",
+            latitude=lat,
+            longitude=lon,
+            temperatura_media=round(temp_media, 1) if temp_media else None,
+            temperatura_maxima=round(temp_maxima, 1) if temp_maxima else None,
+            temperatura_minima=round(temp_minima, 1) if temp_minima else None,
+            precipitacao_total=round(precip_total, 1) if precip_total else None,
+            evapotranspiracao=round(evap_media, 2) if evap_media else None,
+            umidade_media=round(umid_media, 1) if umid_media else None,
+            radiacao_solar=round(rad_total, 1) if rad_total else None,
+            risco_climatico_estimado=risco,
+            fallback=False,
+            error=None
+        )
+        
+        # Cachear por 1 hora (dados históricos mudam pouco)
+        set_cache(cache_key, result.to_dict(), ttl_seconds=3600)
+        
+        return result
+        
+    except Exception as e:
+        # Fallback para dados simulados
+        return _get_fallback_weather(lat, lon, str(e))
+
+def _get_fallback_weather(lat: float, lon: float, error: str) -> WeatherSummary:
+    """Retorna dados climáticos simulados como fallback"""
+    
+    # Dados simulados baseados na localização (heurística simples)
+    # Região Sudeste do Brasil como referência
+    temp_base = 22.0
+    if lat < -25:  # Mais ao sul, mais frio
+        temp_base = 18.0
+    elif lat > -20:  # Mais ao norte, mais quente
+        temp_base = 26.0
+    
+    return WeatherSummary(
+        source="simulado",
+        latitude=lat,
+        longitude=lon,
+        temperatura_media=temp_base,
+        temperatura_maxima=temp_base + 8,
+        temperatura_minima=temp_base - 6,
+        precipitacao_total=120.0,  # mm/mês típico
+        evapotranspiracao=4.5,     # mm/dia típico
+        umidade_media=65.0,        # % típico
+        radiacao_solar=180.0,      # MJ/m² típico mensal
+        risco_climatico_estimado="medio",
+        fallback=True,
+        error=f"Open-Meteo indisponível: {error}"
+    )

package/dist/index.js

@@ -358,7 +358,7 @@ Correja os problemas acima:`);
 }
 
 // src/commands/serve.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync3, openSync, closeSync } from "fs";
 import { spawn } from "child_process";
 async function serveOnCommand() {
   console.log(`\uD83D\uDE80 Iniciando API local do AgroPlan AI...
@@ -421,6 +421,8 @@ async function serveOnCommand() {
     return;
   }
   console.log("\uD83C\uDF10 Iniciando servidor uvicorn...");
+  const out = openSync(paths.logFile, "a");
+  const err = openSync(paths.logFile, "a");
   const child = spawn(uvicornPath, [
     "api:app",
     "--host",
@@ -432,20 +434,16 @@ async function serveOnCommand() {
   ], {
     cwd: paths.backend,
     detached: true,
-    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true,
+    stdio: ["ignore", out, err],
     env: {
       ...process.env,
       CORS_ORIGINS: "https://agroplan-ai.vercel.app,http://localhost:3000,http://127.0.0.1:3000"
     }
   });
   savePid(child.pid);
-  const logStream = Bun.file(paths.logFile).writer();
-  child.stdout?.on("data", (data) => {
-    logStream.write(data);
-  });
-  child.stderr?.on("data", (data) => {
-    logStream.write(data);
-  });
+  closeSync(out);
+  closeSync(err);
   child.unref();
   console.log("\u23F3 Aguardando inicializa\xE7\xE3o...");
   let attempts = 0;
@@ -459,7 +457,8 @@ async function serveOnCommand() {
       console.log("   URL: http://localhost:8000");
       console.log("   Health: http://localhost:8000/health");
       console.log(`
-\uD83D\uDCA1 Use 'agroplan serve off' para parar`);
+\uD83C\uDFAF API rodando em segundo plano - voc\xEA pode fechar este terminal!`);
+      console.log("\uD83D\uDCA1 Use 'agroplan serve off' para parar");
       return;
     }
     attempts++;
@@ -780,7 +779,7 @@ var COMMANDS = {
   open: "Abre o AgroPlan AI no navegador"
 };
 function showHelp() {
-  console.log("\uD83C\uDF31 AgroPlan AI - CLI Local v1.0.6");
+  console.log("\uD83C\uDF31 AgroPlan AI - CLI Local v1.0.8");
   console.log(`   Launcher para modo local acelerado
 `);
   console.log("\uD83D\uDCCB Comandos dispon\xEDveis:");

package/package.json

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