Add libsql dependency

server.py

@@ -31,6 +31,7 @@ from ml_forecast import (
 # ============================================================
 load_dotenv()
 
+
 def _env_str(name: str, default: str = "") -> str:
     v = os.getenv(name)
     if v is None:
@@ -38,6 +39,7 @@ def _env_str(name: str, default: str = "") -> str:
     v = v.strip()
     return v if v != "" else default
 
+
 def _env_int(name: str, default: int) -> int:
     raw = os.getenv(name)
     if raw is None:
@@ -50,6 +52,7 @@ def _env_int(name: str, default: int) -> int:
     except Exception:
         return int(default)
 
+
 DB_PATH = _env_str("FINANCE_DB", "./data/finance.db")
 
 GROQ_API_KEY = _env_str("GROQ_API_KEY", "")
@@ -86,12 +89,15 @@ try:
 except Exception:
     libsql = None
 
+
 def now_iso() -> str:
     return datetime.utcnow().isoformat(timespec="seconds") + "Z"
 
+
 def _ensure_db_dir(db_path: str) -> None:
     os.makedirs(os.path.dirname(db_path) or ".", exist_ok=True)
 
+
 def _maybe_sync(conn: Any) -> None:
     if not USE_TURSO:
         return
@@ -102,6 +108,7 @@ def _maybe_sync(conn: Any) -> None:
     except Exception:
         pass
 
+
 def get_conn():
     _ensure_db_dir(DB_PATH)
 
@@ -134,6 +141,7 @@ def get_conn():
 
     return conn
 
+
 @contextmanager
 def db():
     conn = get_conn()
@@ -145,6 +153,7 @@ def db():
         except Exception:
             pass
 
+
 def _rows_to_dicts(cur: Any, rows: list[Any]) -> list[dict]:
     if not rows:
         return []
@@ -153,6 +162,7 @@ def _rows_to_dicts(cur: Any, rows: list[Any]) -> list[dict]:
     cols = [d[0] for d in (cur.description or [])]
     return [dict(zip(cols, r)) for r in rows]
 
+
 def _row_to_dict(cur: Any, row: Any) -> Optional[dict]:
     if row is None:
         return None
@@ -161,22 +171,26 @@ def _row_to_dict(cur: Any, row: Any) -> Optional[dict]:
     cols = [d[0] for d in (cur.description or [])]
     return dict(zip(cols, row))
 
+
 def q_all(conn: Any, sql: str, params: tuple = ()) -> list[dict]:
     cur = conn.execute(sql, params)
     rows = cur.fetchall()
     return _rows_to_dicts(cur, rows)
 
+
 def q_one(conn: Any, sql: str, params: tuple = ()) -> Optional[dict]:
     cur = conn.execute(sql, params)
     row = cur.fetchone()
     return _row_to_dict(cur, row)
 
+
 def q_scalar(conn: Any, sql: str, params: tuple = (), default: float = 0.0) -> float:
     r = q_one(conn, sql, params)
     if not r:
         return float(default)
     return float(next(iter(r.values())) or default)
 
+
 def _lastrowid(cur: Any, conn: Any) -> int:
     lid = getattr(cur, "lastrowid", None)
     if lid is not None:
@@ -192,6 +206,7 @@ def _lastrowid(cur: Any, conn: Any) -> int:
     except Exception:
         return 0
 
+
 def _rowcount(cur: Any) -> int:
     rc = getattr(cur, "rowcount", None)
     if rc is not None:
@@ -207,6 +222,7 @@ def _rowcount(cur: Any) -> int:
             return 0
     return 0
 
+
 # ============================================================
 # Init DB
 # ============================================================
@@ -280,7 +296,7 @@ def init_db() -> None:
         conn.execute("CREATE INDEX IF NOT EXISTS idx_card_purchases_date ON card_purchases(purchase_date);")
         conn.execute("CREATE INDEX IF NOT EXISTS idx_card_purchases_cat ON card_purchases(category);")
 
-        # modelos ML (serializados em JSON, com base64 de pickle quando necessário)
+        # modelos ML (serializados em JSON)
         conn.execute("""
         CREATE TABLE IF NOT EXISTS ml_models (
           name TEXT PRIMARY KEY,
@@ -292,6 +308,7 @@ def init_db() -> None:
         conn.commit()
         _maybe_sync(conn)
 
+
 def seed_defaults() -> None:
     with db() as conn:
         acc_count = int(q_scalar(conn, "SELECT COUNT(*) AS c FROM accounts", default=0))
@@ -322,6 +339,7 @@ def seed_defaults() -> None:
         conn.commit()
         _maybe_sync(conn)
 
+
 # ============================================================
 # Lifespan
 # ============================================================
@@ -331,7 +349,8 @@ async def lifespan(app: FastAPI):
     seed_defaults()
     yield
 
-app = FastAPI(title="FinanceAI API", version="1.7.0", lifespan=lifespan)
+
+app = FastAPI(title="FinanceAI API", version="1.7.1", lifespan=lifespan)
 
 app.add_middleware(
     CORSMiddleware,
@@ -349,17 +368,21 @@ class AccountIn(BaseModel):
     bank: str = Field(min_length=1)
     type: str = Field(min_length=1)
 
+
 class AccountOut(AccountIn):
     id: int
     created_at: str
 
+
 class CategoryIn(BaseModel):
     name: str = Field(min_length=1)
 
+
 class CategoryOut(CategoryIn):
     id: int
     created_at: str
 
+
 class TransactionIn(BaseModel):
     type: TxType
     amount: float = Field(ge=0)
@@ -368,10 +391,12 @@ class TransactionIn(BaseModel):
     account_id: int
     category: str = Field(min_length=1)
 
+
 class TransactionOut(TransactionIn):
     id: int
     created_at: str
 
+
 class SummaryOut(BaseModel):
     year: int
     month: int
@@ -380,6 +405,7 @@ class SummaryOut(BaseModel):
     balance: float
     count: int
 
+
 class CombinedSummaryOut(BaseModel):
     year: int
     month: int
@@ -391,13 +417,16 @@ class CombinedSummaryOut(BaseModel):
     count_cash: int
     count_card: int
 
+
 class AIRequest(BaseModel):
     question: str = Field(min_length=1)
     context: Dict[str, Any] = Field(default_factory=dict)
 
+
 class AIResponse(BaseModel):
     answer_md: str
 
+
 # Cartões
 class CreditCardIn(BaseModel):
     name: str = Field(min_length=1)
@@ -406,10 +435,12 @@ class CreditCardIn(BaseModel):
     due_day: int = Field(ge=1, le=31)
     credit_limit: float = Field(default=0, ge=0)
 
+
 class CreditCardOut(CreditCardIn):
     id: int
     created_at: str
 
+
 class CardPurchaseIn(BaseModel):
     card_id: int
     amount: float = Field(ge=0)
@@ -417,6 +448,7 @@ class CardPurchaseIn(BaseModel):
     category: str = Field(min_length=1)
     purchase_date: str = Field(min_length=10, max_length=10)  # YYYY-MM-DD
 
+
 class CardPurchaseOut(CardPurchaseIn):
     id: int
     invoice_ym: str
@@ -424,9 +456,11 @@ class CardPurchaseOut(CardPurchaseIn):
     paid_at: Optional[str] = None
     created_at: str
 
+
 class CardPurchasePatch(BaseModel):
     status: PurchaseStatus
 
+
 class InvoiceSummaryOut(BaseModel):
     card_id: int
     invoice_ym: str
@@ -435,12 +469,14 @@ class InvoiceSummaryOut(BaseModel):
     paid_total: float
     count: int
 
+
 class PayInvoiceIn(BaseModel):
     card_id: int
     invoice_ym: str = Field(min_length=7, max_length=7)
     pay_date: str = Field(min_length=10, max_length=10)
     account_id: int
 
+
 # Relatórios
 class MonthlyReportOut(BaseModel):
     year: int
@@ -449,6 +485,7 @@ class MonthlyReportOut(BaseModel):
     transactions: list[Dict[str, Any]]
     card_purchases: list[Dict[str, Any]]
 
+
 # Forecast outputs
 class ForecastDailyOut(BaseModel):
     ok: bool
@@ -461,6 +498,7 @@ class ForecastDailyOut(BaseModel):
     metrics: Dict[str, Any]
     note: str
 
+
 class ForecastTrainOut(BaseModel):
     ok: bool
     basis: str
@@ -470,6 +508,7 @@ class ForecastTrainOut(BaseModel):
     end_ym: str
     metrics: Dict[str, Any]
 
+
 class ForecastOut(BaseModel):
     ok: bool
     basis: str
@@ -490,18 +529,21 @@ def parse_date_yyyy_mm_dd(date_str: str) -> None:
     except ValueError:
         raise HTTPException(status_code=422, detail="date inválida. Use YYYY-MM-DD.")
 
+
 def parse_ym(ym: str) -> None:
     try:
         datetime.strptime(ym, "%Y-%m")
     except ValueError:
         raise HTTPException(status_code=422, detail="valor inválido. Use YYYY-MM.")
 
+
 def add_months(year: int, month: int, delta: int) -> tuple[int, int]:
     m = month - 1 + delta
     y = year + (m // 12)
     m = (m % 12) + 1
     return y, m
 
+
 def compute_invoice_ym(purchase_date: str, closing_day: int) -> str:
     dt = datetime.strptime(purchase_date, "%Y-%m-%d")
     y, m = dt.year, dt.month
@@ -527,6 +569,7 @@ def save_model(conn: Any, name: str, payload: dict) -> None:
     conn.commit()
     _maybe_sync(conn)
 
+
 def load_model(conn: Any, name: str) -> Optional[dict]:
     row = q_one(conn, "SELECT payload_json FROM ml_models WHERE name=?", (name,))
     if not row:
@@ -542,7 +585,8 @@ def load_model(conn: Any, name: str) -> Optional[dict]:
 # ============================================================
 @app.get("/")
 def root():
-    return {"name": "FinanceAI API", "version": "1.7.0", "ok": True}
+    return {"name": "FinanceAI API", "version": "1.7.1", "ok": True}
+
 
 @app.get("/health")
 def health():
@@ -567,6 +611,7 @@ def list_accounts():
     with db() as conn:
         return q_all(conn, "SELECT * FROM accounts ORDER BY id DESC")
 
+
 @app.post("/accounts", response_model=AccountOut)
 def create_account(payload: AccountIn):
     with db() as conn:
@@ -580,6 +625,7 @@ def create_account(payload: AccountIn):
         row = q_one(conn, "SELECT * FROM accounts WHERE id = ?", (new_id,))
         return row  # type: ignore[return-value]
 
+
 @app.delete("/accounts/{account_id}")
 def delete_account(account_id: int):
     with db() as conn:
@@ -599,6 +645,7 @@ def list_categories():
     with db() as conn:
         return q_all(conn, "SELECT * FROM categories ORDER BY name ASC")
 
+
 @app.post("/categories", response_model=CategoryOut)
 def create_category(payload: CategoryIn):
     if payload.name.strip() == "":
@@ -620,6 +667,7 @@ def create_category(payload: CategoryIn):
         row = q_one(conn, "SELECT * FROM categories WHERE id = ?", (new_id,))
         return row  # type: ignore[return-value]
 
+
 @app.delete("/categories/{category_id}")
 def delete_category(category_id: int):
     with db() as conn:
@@ -655,6 +703,7 @@ def list_transactions(year: Optional[int] = None, month: Optional[int] = None, l
             )
         return q_all(conn, "SELECT * FROM transactions ORDER BY date DESC, id DESC LIMIT ?", (limit,))
 
+
 @app.post("/transactions", response_model=TransactionOut)
 def create_transaction(payload: TransactionIn):
     parse_date_yyyy_mm_dd(payload.date)
@@ -683,6 +732,7 @@ def create_transaction(payload: TransactionIn):
         row = q_one(conn, "SELECT * FROM transactions WHERE id = ?", (new_id,))
         return row  # type: ignore[return-value]
 
+
 @app.delete("/transactions/{tx_id}")
 def delete_transaction(tx_id: int):
     with db() as conn:
@@ -694,6 +744,108 @@ def delete_transaction(tx_id: int):
         return {"ok": True}
 
 
+# ============================================================
+# Transactions (Combined) — usado pelo frontend
+#  - Competência: caixa (ym) + compras cartão (invoice_ym=ym)
+#  - Por padrão NÃO inclui pagamento de fatura (evita dupla contagem)
+# ============================================================
+@app.get("/transactions/combined")
+def list_transactions_combined(
+    year: int,
+    month: int,
+    limit: int = 5000,
+    include_card_payments: bool = False,
+):
+    if month < 1 or month > 12:
+        raise HTTPException(status_code=422, detail="month deve estar entre 1 e 12.")
+    if limit < 1 or limit > 20000:
+        raise HTTPException(status_code=422, detail="limit deve estar entre 1 e 20000.")
+
+    ym = f"{year:04d}-{month:02d}"
+
+    with db() as conn:
+        # Caixa
+        if include_card_payments:
+            tx = q_all(
+                conn,
+                """
+                SELECT id, type, amount, description, date, account_id, category, created_at
+                FROM transactions
+                WHERE substr(date,1,7)=?
+                ORDER BY date DESC, id DESC
+                LIMIT ?
+                """,
+                (ym, limit),
+            )
+        else:
+            tx = q_all(
+                conn,
+                """
+                SELECT id, type, amount, description, date, account_id, category, created_at
+                FROM transactions
+                WHERE substr(date,1,7)=?
+                  AND NOT (type='expense' AND category=?)
+                ORDER BY date DESC, id DESC
+                LIMIT ?
+                """,
+                (ym, CATEGORY_CARD_PAYMENT, limit),
+            )
+
+        # Cartão (por competência)
+        cp = q_all(
+            conn,
+            """
+            SELECT id, card_id, amount, description, category, purchase_date, invoice_ym, status, paid_at, created_at
+            FROM card_purchases
+            WHERE invoice_ym=?
+            ORDER BY purchase_date DESC, id DESC
+            LIMIT ?
+            """,
+            (ym, limit),
+        )
+
+        combined: list[dict] = []
+
+        for t in tx:
+            combined.append(
+                {
+                    "source": "cash",
+                    "id": t.get("id"),
+                    "type": t.get("type"),
+                    "amount": float(t.get("amount") or 0.0),
+                    "description": t.get("description") or "",
+                    "date": t.get("date"),
+                    "category": t.get("category") or "",
+                    "account_id": t.get("account_id"),
+                    "created_at": t.get("created_at"),
+                }
+            )
+
+        for p in cp:
+            combined.append(
+                {
+                    "source": "card",
+                    "id": p.get("id"),
+                    "type": "expense",
+                    "amount": float(p.get("amount") or 0.0),
+                    "description": p.get("description") or "",
+                    # no front ele usa t.date; aqui a data é a purchase_date
+                    "date": p.get("purchase_date"),
+                    "category": p.get("category") or "",
+                    "account_id": None,
+                    "card_id": p.get("card_id"),
+                    "invoice_ym": p.get("invoice_ym"),
+                    "status": p.get("status"),
+                    "paid_at": p.get("paid_at"),
+                    "created_at": p.get("created_at"),
+                }
+            )
+
+        # Ordenação final (igual ao front)
+        combined.sort(key=lambda r: (str(r.get("date") or ""), int(r.get("id") or 0)), reverse=True)
+        return combined[:limit]
+
+
 # ============================================================
 # Summary (caixa) + combinado (caixa + cartão)
 # ============================================================
@@ -734,7 +886,15 @@ def get_summary(year: int, month: int, exclude_card_payments: bool = True):
         income = float(row.get("income") or 0.0)
         expense = float(row.get("expense") or 0.0)
 
-        return {"year": year, "month": month, "income": income, "expense": expense, "balance": income - expense, "count": int(row.get("cnt") or 0)}
+        return {
+            "year": year,
+            "month": month,
+            "income": income,
+            "expense": expense,
+            "balance": income - expense,
+            "count": int(row.get("cnt") or 0),
+        }
+
 
 @app.get("/summary/combined", response_model=CombinedSummaryOut)
 def get_summary_combined(year: int, month: int):
@@ -786,7 +946,7 @@ def get_summary_combined(year: int, month: int):
 
 
 # ============================================================
-# Charts (mantidos)
+# Charts (caixa)
 # ============================================================
 @app.get("/charts/timeseries")
 def chart_timeseries(year: int, month: int, exclude_card_payments: bool = True):
@@ -824,6 +984,7 @@ def chart_timeseries(year: int, month: int, exclude_card_payments: bool = True):
             (ym,),
         )
 
+
 @app.get("/charts/categories")
 def chart_categories(year: int, month: int, tx_type: TxType = "expense", exclude_card_payments: bool = True):
     if month < 1 or month > 12:
@@ -860,6 +1021,123 @@ def chart_categories(year: int, month: int, tx_type: TxType = "expense", exclude
         )
 
 
+# ============================================================
+# Charts (combined) — usado pelo frontend
+#  - timeseries: soma despesa real de caixa (sem pagamento) + cartão (invoice_ym), por data
+#  - categories: soma por categoria (caixa real + cartão)
+# ============================================================
+@app.get("/charts/combined/timeseries")
+def chart_combined_timeseries(year: int, month: int):
+    if month < 1 or month > 12:
+        raise HTTPException(status_code=422, detail="month deve estar entre 1 e 12.")
+    ym = f"{year:04d}-{month:02d}"
+
+    with db() as conn:
+        # Caixa: receitas por dia (somente YM)
+        cash_inc = q_all(
+            conn,
+            """
+            SELECT date, SUM(amount) AS income
+            FROM transactions
+            WHERE substr(date,1,7)=? AND type='income'
+            GROUP BY date
+            """,
+            (ym,),
+        )
+        cash_exp = q_all(
+            conn,
+            """
+            SELECT date, SUM(amount) AS expense_cash
+            FROM transactions
+            WHERE substr(date,1,7)=?
+              AND type='expense'
+              AND category<>?
+            GROUP BY date
+            """,
+            (ym, CATEGORY_CARD_PAYMENT),
+        )
+
+        # Cartão: despesas por purchase_date, filtrando pela competência invoice_ym
+        card_exp = q_all(
+            conn,
+            """
+            SELECT purchase_date AS date, SUM(amount) AS expense_card
+            FROM card_purchases
+            WHERE invoice_ym=?
+            GROUP BY purchase_date
+            """,
+            (ym,),
+        )
+
+        # Merge em mapa
+        m: dict[str, dict[str, float]] = {}
+
+        for r in cash_inc:
+            d = str(r.get("date"))
+            m.setdefault(d, {"income": 0.0, "expense_total": 0.0})
+            m[d]["income"] += float(r.get("income") or 0.0)
+
+        for r in cash_exp:
+            d = str(r.get("date"))
+            m.setdefault(d, {"income": 0.0, "expense_total": 0.0})
+            m[d]["expense_total"] += float(r.get("expense_cash") or 0.0)
+
+        for r in card_exp:
+            d = str(r.get("date"))
+            m.setdefault(d, {"income": 0.0, "expense_total": 0.0})
+            m[d]["expense_total"] += float(r.get("expense_card") or 0.0)
+
+        out = [{"date": k, "income": v["income"], "expense_total": v["expense_total"]} for k, v in m.items()]
+        out.sort(key=lambda x: str(x.get("date") or ""))
+        return out
+
+
+@app.get("/charts/combined/categories")
+def chart_combined_categories(year: int, month: int):
+    if month < 1 or month > 12:
+        raise HTTPException(status_code=422, detail="month deve estar entre 1 e 12.")
+    ym = f"{year:04d}-{month:02d}"
+
+    with db() as conn:
+        cash = q_all(
+            conn,
+            """
+            SELECT category, SUM(amount) AS total
+            FROM transactions
+            WHERE substr(date,1,7)=?
+              AND type='expense'
+              AND category<>?
+            GROUP BY category
+            """,
+            (ym, CATEGORY_CARD_PAYMENT),
+        )
+
+        card = q_all(
+            conn,
+            """
+            SELECT category, SUM(amount) AS total
+            FROM card_purchases
+            WHERE invoice_ym=?
+            GROUP BY category
+            """,
+            (ym,),
+        )
+
+        agg: dict[str, float] = {}
+
+        for r in cash:
+            c = str(r.get("category") or "Geral")
+            agg[c] = agg.get(c, 0.0) + float(r.get("total") or 0.0)
+
+        for r in card:
+            c = str(r.get("category") or "Geral")
+            agg[c] = agg.get(c, 0.0) + float(r.get("total") or 0.0)
+
+        out = [{"category": k, "total": v} for k, v in agg.items()]
+        out.sort(key=lambda x: float(x.get("total") or 0.0), reverse=True)
+        return out
+
+
 # ============================================================
 # Cartões
 # ============================================================
@@ -868,6 +1146,7 @@ def list_cards():
     with db() as conn:
         return q_all(conn, "SELECT * FROM credit_cards ORDER BY id DESC")
 
+
 @app.post("/cards", response_model=CreditCardOut)
 def create_card(payload: CreditCardIn):
     with db() as conn:
@@ -884,6 +1163,7 @@ def create_card(payload: CreditCardIn):
         row = q_one(conn, "SELECT * FROM credit_cards WHERE id=?", (new_id,))
         return row  # type: ignore[return-value]
 
+
 @app.delete("/cards/{card_id}")
 def delete_card(card_id: int):
     with db() as conn:
@@ -894,6 +1174,7 @@ def delete_card(card_id: int):
             raise HTTPException(status_code=404, detail="Cartão não encontrado.")
         return {"ok": True}
 
+
 @app.get("/cards/{card_id}/invoices")
 def list_card_invoices(card_id: int):
     with db() as conn:
@@ -913,6 +1194,7 @@ def list_card_invoices(card_id: int):
             (card_id,),
         )
 
+
 @app.get("/cards/{card_id}/purchases", response_model=list[CardPurchaseOut])
 def list_card_purchases(card_id: int, invoice_ym: Optional[str] = None, limit: int = 500):
     if limit < 1 or limit > 5000:
@@ -945,6 +1227,7 @@ def list_card_purchases(card_id: int, invoice_ym: Optional[str] = None, limit: i
             (card_id, limit),
         )
 
+
 @app.post("/cards/purchases", response_model=CardPurchaseOut)
 def create_card_purchase(payload: CardPurchaseIn):
     parse_date_yyyy_mm_dd(payload.purchase_date)
@@ -966,6 +1249,7 @@ def create_card_purchase(payload: CardPurchaseIn):
         row = q_one(conn, "SELECT * FROM card_purchases WHERE id=?", (new_id,))
         return row  # type: ignore[return-value]
 
+
 @app.patch("/cards/purchases/{purchase_id}", response_model=dict)
 def patch_card_purchase(purchase_id: int, payload: CardPurchasePatch):
     if payload.status not in ("pending", "paid"):
@@ -982,6 +1266,7 @@ def patch_card_purchase(purchase_id: int, payload: CardPurchasePatch):
         _maybe_sync(conn)
         return {"ok": True}
 
+
 @app.delete("/cards/purchases/{purchase_id}")
 def delete_card_purchase(purchase_id: int):
     with db() as conn:
@@ -992,6 +1277,7 @@ def delete_card_purchase(purchase_id: int):
             raise HTTPException(status_code=404, detail="Compra não encontrada.")
         return {"ok": True}
 
+
 @app.get("/cards/{card_id}/invoice-summary", response_model=InvoiceSummaryOut)
 def invoice_summary(card_id: int, invoice_ym: str):
     parse_ym(invoice_ym)
@@ -1022,6 +1308,7 @@ def invoice_summary(card_id: int, invoice_ym: str):
             "count": int(row.get("cnt") or 0),
         }
 
+
 @app.post("/cards/pay-invoice")
 def pay_invoice(payload: PayInvoiceIn):
     parse_ym(payload.invoice_ym)
@@ -1095,6 +1382,7 @@ def _fetch_monthly_report(conn: Any, ym: str) -> tuple[list[dict], list[dict]]:
     )
     return tx, cp
 
+
 @app.get("/reports/monthly", response_model=MonthlyReportOut)
 def report_monthly(year: int, month: int):
     if month < 1 or month > 12:
@@ -1104,6 +1392,7 @@ def report_monthly(year: int, month: int):
         tx, cp = _fetch_monthly_report(conn, ym)
         return {"year": year, "month": month, "ym": ym, "transactions": tx, "card_purchases": cp}
 
+
 @app.get("/reports/export")
 def report_export(year: int, month: int, fmt: ExportFormat = "csv"):
     if month < 1 or month > 12:
@@ -1148,7 +1437,7 @@ def ask_ai(payload: AIRequest):
         url=f"{GROQ_BASE}/chat/completions",
         method="POST",
         data=json.dumps(body).encode("utf-8"),
-        headers={"Content-Type": "application/json", "Authorization": f"Bearer {GROQ_API_KEY}", "User-Agent": "FinanceAI/1.7.0"},
+        headers={"Content-Type": "application/json", "Authorization": f"Bearer {GROQ_API_KEY}", "User-Agent": "FinanceAI/1.7.1"},
     )
     try:
         with urllib.request.urlopen(req, timeout=60) as resp:
@@ -1199,6 +1488,7 @@ def _fetch_daily_income_expense(conn: Any, account_id: Optional[int]) -> list[di
         (account_id,),
     )
 
+
 @app.post("/forecast/daily/train")
 def forecast_daily_train(account_id: Optional[int] = None, lags: int = 14):
     with db() as conn:
@@ -1214,6 +1504,7 @@ def forecast_daily_train(account_id: Optional[int] = None, lags: int = 14):
         save_model(conn, name, payload)
         return {"ok": True, "trained_at": payload["trained_at"], "basis": payload["basis"], "lags": payload["lags"], "note": payload.get("note")}
 
+
 @app.get("/forecast/daily", response_model=ForecastDailyOut)
 def forecast_daily(days: int = 7, auto_train: bool = True, lags: int = 14, account_id: Optional[int] = None):
     with db() as conn:
@@ -1257,10 +1548,9 @@ def forecast_daily(days: int = 7, auto_train: bool = True, lags: int = 14, accou
 
 
 # ============================================================
-# Forecast — competência (despesa real = caixa sem pagamento + cartão por invoice_ym)
+# Forecast — competência mensal (despesa real = caixa sem pagamento + cartão por invoice_ym)
 # ============================================================
 def _fetch_monthly_competencia(conn: Any, account_id: Optional[int], include_card: bool) -> list[dict]:
-    # Descobre min/max de meses considerando caixa e (opcional) cartão
     if account_id is None:
         r1 = q_one(conn, "SELECT MIN(substr(date,1,7)) AS mn, MAX(substr(date,1,7)) AS mx FROM transactions")
     else:
@@ -1277,7 +1567,6 @@ def _fetch_monthly_competencia(conn: Any, account_id: Optional[int], include_car
 
     start_ym, end_ym = min(mins), max(maxs)
 
-    # sequência mensal
     def month_seq(start_ym: str, end_ym: str):
         sy, sm = start_ym.split("-")
         ey, em = end_ym.split("-")
@@ -1344,6 +1633,7 @@ def _fetch_monthly_competencia(conn: Any, account_id: Optional[int], include_car
 
     return series
 
+
 @app.post("/forecast/train", response_model=ForecastTrainOut)
 def forecast_train(lags: int = 6, account_id: Optional[int] = None, include_card: bool = True):
     with db() as conn:
@@ -1374,6 +1664,7 @@ def forecast_train(lags: int = 6, account_id: Optional[int] = None, include_card
             "metrics": metrics,
         }
 
+
 @app.get("/forecast/status")
 def forecast_status(account_id: Optional[int] = None, include_card: bool = True, min_months: int = 12, lags: int = 6):
     with db() as conn:
@@ -1394,6 +1685,7 @@ def forecast_status(account_id: Optional[int] = None, include_card: bool = True,
             "note": "O treino mensal exige histórico suficiente (>= lags + 6). Recomenda-se >= 12 meses.",
         }
 
+
 @app.get("/forecast", response_model=ForecastOut)
 def forecast_get(horizon: int = 12, auto_train: bool = True, lags: int = 6, account_id: Optional[int] = None, include_card: bool = True):
     with db() as conn: