agroplan-ai-cli 1.0.30 → 1.0.31

package/backend-template/VERSION.json

@@ -1,6 +1,6 @@
 {
-  "cli_version": "1.0.30",
-  "backend_template_version": "1.0.30",
+  "cli_version": "1.0.31",
+  "backend_template_version": "1.0.31",
   "zarc_index_version": "2025-2026-fast-index-v2",
   "price_index_version": "2025-05-reference-v1",
   "features": [
@@ -18,7 +18,9 @@
     "market_profit_confidence_refinement",
     "market_profit_comparative_evaluation",
     "market_profit_experimental_optimizer",
-    "smart_crop_calendar_engine"
+    "smart_crop_calendar_engine",
+    "manual_field_registration",
+    "crop_calendar_from_manual_field"
   ],
-  "generated_at": "2026-05-10T15:30:00Z"
+  "generated_at": "2026-05-10T16:15:00Z"
 }

package/backend-template/api.py

@@ -1417,6 +1417,189 @@ def obter_cultura_info(cultura: str):
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+# Endpoints de Talhões Manuais
+
+@app.get("/planejamento/talhoes")
+def listar_talhoes():
+    """Lista todos os talhões cadastrados pelo usuário"""
+    try:
+        from core.field_storage import listar_talhoes_usuario
+        
+        fields = listar_talhoes_usuario()
+        
+        return {
+            "total": len(fields),
+            "talhoes": fields
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/planejamento/talhoes")
+def criar_talhao(field_data: dict):
+    """Cria um novo talhão"""
+    try:
+        from core.field_storage import criar_talhao_usuario
+        from core.planning_models import ManualFieldCreate
+        
+        # Validar dados
+        validated = ManualFieldCreate(**field_data)
+        
+        # Criar talhão
+        new_field = criar_talhao_usuario(validated.model_dump())
+        
+        return new_field
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/planejamento/talhoes/{field_id}")
+def obter_talhao(field_id: str):
+    """Obtém um talhão pelo ID"""
+    try:
+        from core.field_storage import obter_talhao_usuario
+        
+        field = obter_talhao_usuario(field_id)
+        
+        if not field:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Talhão '{field_id}' não encontrado"
+            )
+        
+        return field
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.put("/planejamento/talhoes/{field_id}")
+def atualizar_talhao(field_id: str, field_data: dict):
+    """Atualiza um talhão existente"""
+    try:
+        from core.field_storage import atualizar_talhao_usuario
+        from core.planning_models import ManualFieldUpdate
+        
+        # Validar dados
+        validated = ManualFieldUpdate(**field_data)
+        
+        # Atualizar apenas campos fornecidos
+        update_data = {k: v for k, v in validated.model_dump().items() if v is not None}
+        
+        # Atualizar talhão
+        updated_field = atualizar_talhao_usuario(field_id, update_data)
+        
+        if not updated_field:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Talhão '{field_id}' não encontrado"
+            )
+        
+        return updated_field
+    except HTTPException:
+        raise
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.delete("/planejamento/talhoes/{field_id}")
+def remover_talhao(field_id: str):
+    """Remove um talhão"""
+    try:
+        from core.field_storage import remover_talhao_usuario
+        
+        removed = remover_talhao_usuario(field_id)
+        
+        if not removed:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Talhão '{field_id}' não encontrado"
+            )
+        
+        return {
+            "message": "Talhão removido com sucesso",
+            "id": field_id
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/planejamento/talhoes/{field_id}/calendario")
+def gerar_calendario_talhao(field_id: str, request: dict):
+    """Gera calendário agrícola para um talhão cadastrado"""
+    try:
+        from core.field_storage import obter_talhao_usuario
+        from core.crop_calendar_engine import gerar_calendario_cultura
+        from core.planning_models import Field, SoilType, Slope, WaterAvailability, GenerateCalendarRequest
+        from datetime import datetime
+        
+        # Validar request
+        validated = GenerateCalendarRequest(**request)
+        
+        # Buscar talhão
+        field_data = obter_talhao_usuario(field_id)
+        
+        if not field_data:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Talhão '{field_id}' não encontrado"
+            )
+        
+        # Parsear data de plantio
+        try:
+            planting_date = datetime.fromisoformat(validated.planting_date).date()
+        except Exception:
+            raise HTTPException(
+                status_code=400,
+                detail="Formato de data inválido. Use ISO 8601 (YYYY-MM-DD)"
+            )
+        
+        # Criar objeto Field
+        field = Field(
+            id=field_data["id"],
+            property_id="user",
+            name=field_data["name"],
+            area_ha=field_data["area_ha"],
+            soil_type=SoilType(field_data["soil_type"]),
+            slope=Slope(field_data["slope"]),
+            water_availability=WaterAvailability(field_data["water_availability"])
+        )
+        
+        # Gerar calendário
+        resultado = gerar_calendario_cultura(
+            cultura=validated.cultura,
+            planting_date=planting_date,
+            field=field,
+            crop_plan_id=None
+        )
+        
+        # Adicionar dados do talhão na resposta
+        resultado["field_data"] = field_data
+        
+        return converter_tipos_python(resultado)
+        
+    except HTTPException:
+        raise
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    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 calendário para o talhão."
+            )
+
 @app.post("/cache/limpar")
 def limpar_cache(request: Request):
     """Limpa o cache de resultados pesados (protegido por token)"""

package/backend-template/core/field_storage.py

@@ -0,0 +1,175 @@
+"""
+Storage simples para talhões do usuário
+
+Persistência em JSON local:
+- API Local: dados persistem no PC do usuário (~/.agroplan/backend/data/user_fields/)
+- API Render: dados temporários/voláteis (perdem-se ao reiniciar)
+
+Fase futura: Migrar para banco de dados PostgreSQL
+"""
+
+import json
+import os
+import uuid
+from datetime import datetime
+from typing import List, Dict, Optional
+from pathlib import Path
+
+
+# Diretório de dados
+DATA_DIR = Path(__file__).parent.parent / "data" / "user_fields"
+FIELDS_FILE = DATA_DIR / "fields.json"
+
+
+def _ensure_data_dir():
+    """Garante que o diretório de dados existe"""
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    
+    # Criar arquivo vazio se não existir
+    if not FIELDS_FILE.exists():
+        with open(FIELDS_FILE, 'w', encoding='utf-8') as f:
+            json.dump([], f)
+
+
+def _load_fields() -> List[Dict]:
+    """Carrega todos os talhões do arquivo JSON"""
+    _ensure_data_dir()
+    
+    try:
+        with open(FIELDS_FILE, 'r', encoding='utf-8') as f:
+            return json.load(f)
+    except (json.JSONDecodeError, FileNotFoundError):
+        return []
+
+
+def _save_fields(fields: List[Dict]):
+    """
+    Salva talhões no arquivo JSON com escrita segura.
+    
+    Usa arquivo temporário + rename para evitar corrupção.
+    """
+    _ensure_data_dir()
+    
+    # Escrever em arquivo temporário
+    temp_file = FIELDS_FILE.with_suffix('.tmp')
+    
+    try:
+        with open(temp_file, 'w', encoding='utf-8') as f:
+            json.dump(fields, f, indent=2, ensure_ascii=False)
+        
+        # Renomear atomicamente
+        temp_file.replace(FIELDS_FILE)
+    except Exception as e:
+        # Limpar arquivo temporário em caso de erro
+        if temp_file.exists():
+            temp_file.unlink()
+        raise e
+
+
+def listar_talhoes_usuario() -> List[Dict]:
+    """
+    Lista todos os talhões do usuário.
+    
+    Returns:
+        Lista de talhões
+    """
+    return _load_fields()
+
+
+def criar_talhao_usuario(data: Dict) -> Dict:
+    """
+    Cria um novo talhão.
+    
+    Args:
+        data: Dados do talhão (sem id, created_at, updated_at)
+    
+    Returns:
+        Talhão criado com id e timestamps
+    """
+    fields = _load_fields()
+    
+    # Gerar novo talhão
+    now = datetime.now().isoformat()
+    new_field = {
+        "id": str(uuid.uuid4()),
+        **data,
+        "created_at": now,
+        "updated_at": now
+    }
+    
+    fields.append(new_field)
+    _save_fields(fields)
+    
+    return new_field
+
+
+def obter_talhao_usuario(field_id: str) -> Optional[Dict]:
+    """
+    Obtém um talhão pelo ID.
+    
+    Args:
+        field_id: ID do talhão
+    
+    Returns:
+        Talhão ou None se não encontrado
+    """
+    fields = _load_fields()
+    
+    for field in fields:
+        if field.get("id") == field_id:
+            return field
+    
+    return None
+
+
+def atualizar_talhao_usuario(field_id: str, data: Dict) -> Optional[Dict]:
+    """
+    Atualiza um talhão existente.
+    
+    Args:
+        field_id: ID do talhão
+        data: Novos dados (sem id, created_at, updated_at)
+    
+    Returns:
+        Talhão atualizado ou None se não encontrado
+    """
+    fields = _load_fields()
+    
+    for i, field in enumerate(fields):
+        if field.get("id") == field_id:
+            # Preservar id e created_at, atualizar updated_at
+            updated_field = {
+                "id": field["id"],
+                **data,
+                "created_at": field["created_at"],
+                "updated_at": datetime.now().isoformat()
+            }
+            
+            fields[i] = updated_field
+            _save_fields(fields)
+            
+            return updated_field
+    
+    return None
+
+
+def remover_talhao_usuario(field_id: str) -> bool:
+    """
+    Remove um talhão.
+    
+    Args:
+        field_id: ID do talhão
+    
+    Returns:
+        True se removido, False se não encontrado
+    """
+    fields = _load_fields()
+    
+    original_length = len(fields)
+    fields = [f for f in fields if f.get("id") != field_id]
+    
+    if len(fields) < original_length:
+        _save_fields(fields)
+        return True
+    
+    return False

package/backend-template/core/planning_models.py

@@ -11,12 +11,18 @@ Define as entidades principais do sistema de planejamento agrícola:
 - UserObservation: Observação do usuário
 - Intervention: Intervenção/replanejamento
 - PlanningSession: Sessão de planejamento
+
+Modelos Pydantic para API:
+- ManualFieldCreate: Criação de talhão manual
+- ManualFieldUpdate: Atualização de talhão manual
+- ManualFieldResponse: Resposta de talhão manual
 """
 
 from dataclasses import dataclass, field
 from datetime import date, datetime
 from typing import Optional, List, Dict
 from enum import Enum
+from pydantic import BaseModel, Field as PydanticField, field_validator
 
 
 # Enums para tipos padronizados
@@ -364,3 +370,115 @@ class PlanningSession:
             "cultures_recommended": self.cultures_recommended,
             "created_at": self.created_at.isoformat()
         }
+
+
+# Modelos Pydantic para API
+
+class ManualFieldCreate(BaseModel):
+    """Modelo para criação de talhão manual"""
+    name: str = PydanticField(..., min_length=1, max_length=100, description="Nome do talhão")
+    area_ha: float = PydanticField(..., gt=0, description="Área em hectares")
+    soil_type: str = PydanticField(..., description="Tipo de solo")
+    slope: str = PydanticField(..., description="Tipo de relevo")
+    water_availability: str = PydanticField(..., description="Disponibilidade de água")
+    uf: Optional[str] = PydanticField(None, min_length=2, max_length=2, description="UF")
+    municipio: Optional[str] = PydanticField(None, max_length=100, description="Município")
+    lat: Optional[float] = PydanticField(None, ge=-90, le=90, description="Latitude")
+    lon: Optional[float] = PydanticField(None, ge=-180, le=180, description="Longitude")
+    
+    @field_validator('soil_type')
+    @classmethod
+    def validate_soil_type(cls, v: str) -> str:
+        allowed = ['argiloso', 'arenoso', 'misto', 'siltoso']
+        if v not in allowed:
+            raise ValueError(f'soil_type deve ser um de: {", ".join(allowed)}')
+        return v
+    
+    @field_validator('slope')
+    @classmethod
+    def validate_slope(cls, v: str) -> str:
+        allowed = ['plano', 'suave', 'moderado', 'ingreme']
+        if v not in allowed:
+            raise ValueError(f'slope deve ser um de: {", ".join(allowed)}')
+        return v
+    
+    @field_validator('water_availability')
+    @classmethod
+    def validate_water_availability(cls, v: str) -> str:
+        allowed = ['baixa', 'media', 'alta']
+        if v not in allowed:
+            raise ValueError(f'water_availability deve ser um de: {", ".join(allowed)}')
+        return v
+
+
+class ManualFieldUpdate(BaseModel):
+    """Modelo para atualização de talhão manual"""
+    name: Optional[str] = PydanticField(None, min_length=1, max_length=100)
+    area_ha: Optional[float] = PydanticField(None, gt=0)
+    soil_type: Optional[str] = None
+    slope: Optional[str] = None
+    water_availability: Optional[str] = None
+    uf: Optional[str] = PydanticField(None, min_length=2, max_length=2)
+    municipio: Optional[str] = PydanticField(None, max_length=100)
+    lat: Optional[float] = PydanticField(None, ge=-90, le=90)
+    lon: Optional[float] = PydanticField(None, ge=-180, le=180)
+    
+    @field_validator('soil_type')
+    @classmethod
+    def validate_soil_type(cls, v: Optional[str]) -> Optional[str]:
+        if v is not None:
+            allowed = ['argiloso', 'arenoso', 'misto', 'siltoso']
+            if v not in allowed:
+                raise ValueError(f'soil_type deve ser um de: {", ".join(allowed)}')
+        return v
+    
+    @field_validator('slope')
+    @classmethod
+    def validate_slope(cls, v: Optional[str]) -> Optional[str]:
+        if v is not None:
+            allowed = ['plano', 'suave', 'moderado', 'ingreme']
+            if v not in allowed:
+                raise ValueError(f'slope deve ser um de: {", ".join(allowed)}')
+        return v
+    
+    @field_validator('water_availability')
+    @classmethod
+    def validate_water_availability(cls, v: Optional[str]) -> Optional[str]:
+        if v is not None:
+            allowed = ['baixa', 'media', 'alta']
+            if v not in allowed:
+                raise ValueError(f'water_availability deve ser um de: {", ".join(allowed)}')
+        return v
+
+
+class ManualFieldResponse(BaseModel):
+    """Modelo de resposta de talhão manual"""
+    id: str
+    name: str
+    area_ha: float
+    soil_type: str
+    slope: str
+    water_availability: str
+    uf: Optional[str] = None
+    municipio: Optional[str] = None
+    lat: Optional[float] = None
+    lon: Optional[float] = None
+    created_at: str
+    updated_at: str
+    
+    class Config:
+        from_attributes = True
+
+
+class GenerateCalendarRequest(BaseModel):
+    """Modelo para geração de calendário"""
+    cultura: str = PydanticField(..., description="Nome da cultura")
+    planting_date: str = PydanticField(..., description="Data de plantio (YYYY-MM-DD)")
+    
+    @field_validator('cultura')
+    @classmethod
+    def validate_cultura(cls, v: str) -> str:
+        allowed = ['soja', 'milho', 'feijao']
+        if v not in allowed:
+            raise ValueError(f'cultura deve ser uma de: {", ".join(allowed)}')
+        return v

package/package.json

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