added reminder

backend/app/reminders/__init__.py

@@ -0,0 +1,3 @@
+from app.reminders.service import RemindersService
+
+__all__ = ["RemindersService"]

backend/app/reminders/context.py

@@ -0,0 +1,33 @@
+from typing import Any
+
+from sqlalchemy.orm import Session
+
+from app.reminders.service import RemindersService
+
+MAX_IN_CONTEXT = 10
+
+
+def get_reminders_snapshot(db: Session) -> dict[str, Any]:
+    return RemindersService(db).snapshot()
+
+
+def format_reminders_context(snapshot: dict[str, Any]) -> str:
+    lines = ["[Напоминания]"]
+    upcoming = snapshot.get("upcoming") or []
+    tz = snapshot.get("timezone", "Europe/Moscow")
+
+    if not upcoming:
+        lines.append(
+            "Ближайших напоминаний нет. "
+            "create_reminder для «напомни через 15 минут», «завтра утром», точной даты."
+        )
+        return "\n".join(lines)
+
+    lines.append(f"Часовой пояс: {tz}. Tools: list_reminders, create_reminder, update_reminder, delete_reminder, complete_reminder.")
+    for item in upcoming[:MAX_IN_CONTEXT]:
+        rec = item.get("recurrence", "none")
+        rec_label = f" · повтор: {rec}" if rec and rec != "none" else ""
+        lines.append(
+            f"- #{item['id']} **{item['title']}** · {item.get('due_at_local', item.get('due_at'))}{rec_label}"
+        )
+    return "\n".join(lines)

backend/app/reminders/fire.py

@@ -0,0 +1,60 @@
+import logging
+from datetime import datetime, timezone
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from app.chat.notice_inbox import post_notice_to_latest_chat
+from app.db.models import Reminder
+from app.reminders.notify import bump_notify_seq
+from app.reminders.service import RECURRENCE_NONE, _advance_due, _format_local
+
+logger = logging.getLogger(__name__)
+
+
+def _utcnow() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def check_due_reminders(db: Session) -> int:
+    now = _utcnow()
+    stmt = (
+        select(Reminder)
+        .where(
+            Reminder.enabled.is_(True),
+            Reminder.completed_at.is_(None),
+            Reminder.due_at <= now,
+        )
+        .order_by(Reminder.due_at.asc())
+    )
+    rows = list(db.scalars(stmt).all())
+    fired = 0
+
+    for row in rows:
+        if row.last_fired_at and row.last_fired_at >= row.due_at:
+            continue
+
+        local_when = _format_local(row.due_at, row.timezone, all_day=row.all_day)
+        notice = f"📅 **Напоминание** · {row.title}\n\n_{local_when}_"
+        if row.notes:
+            notice += f"\n{row.notes}"
+
+        post_notice_to_latest_chat(notice)
+        row.last_fired_at = now
+
+        if row.recurrence == RECURRENCE_NONE:
+            row.completed_at = now
+            row.enabled = False
+        else:
+            row.due_at = _advance_due(row.due_at, row.recurrence)
+            row.last_fired_at = None
+
+        row.updated_at = now
+        fired += 1
+
+    if fired:
+        db.commit()
+        bump_notify_seq(db)
+        logger.info("Reminders fired: %d", fired)
+
+    return fired

backend/app/reminders/notify.py

@@ -0,0 +1,19 @@
+from sqlalchemy.orm import Session
+
+from app.homelab.state import get_state, set_state
+
+NOTIFY_SEQ_KEY = "reminders_notify_seq"
+
+
+def get_notify_seq(db: Session) -> int:
+    raw = get_state(db, NOTIFY_SEQ_KEY)
+    try:
+        return int(raw or 0)
+    except ValueError:
+        return 0
+
+
+def bump_notify_seq(db: Session) -> int:
+    seq = get_notify_seq(db) + 1
+    set_state(db, NOTIFY_SEQ_KEY, str(seq))
+    return seq

backend/app/reminders/service.py

@@ -0,0 +1,226 @@
+import calendar
+from datetime import datetime, timedelta, timezone
+from typing import Any
+from zoneinfo import ZoneInfo
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from app.db.models import Reminder
+from app.homelab.context import resolve_timezone
+from app.reminders.notify import bump_notify_seq, get_notify_seq
+
+RECURRENCE_NONE = "none"
+RECURRENCE_DAILY = "daily"
+RECURRENCE_WEEKLY = "weekly"
+RECURRENCE_MONTHLY = "monthly"
+VALID_RECURRENCE = frozenset({RECURRENCE_NONE, RECURRENCE_DAILY, RECURRENCE_WEEKLY, RECURRENCE_MONTHLY})
+
+
+def _utcnow() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+def _parse_due_at(raw: str, tz_name: str) -> datetime:
+    clean = raw.strip()
+    if not clean:
+        raise ValueError("due_at не может быть пустым")
+    try:
+        dt = datetime.fromisoformat(clean.replace("Z", "+00:00"))
+    except ValueError as exc:
+        raise ValueError(f"Неверный формат даты: {raw}") from exc
+    if dt.tzinfo is None:
+        try:
+            dt = dt.replace(tzinfo=ZoneInfo(tz_name))
+        except Exception:
+            dt = dt.replace(tzinfo=ZoneInfo("Europe/Moscow"))
+    return dt.astimezone(timezone.utc)
+
+
+def _advance_due(due_at: datetime, recurrence: str) -> datetime:
+    if recurrence == RECURRENCE_DAILY:
+        return due_at + timedelta(days=1)
+    if recurrence == RECURRENCE_WEEKLY:
+        return due_at + timedelta(weeks=1)
+    if recurrence == RECURRENCE_MONTHLY:
+        month = due_at.month + 1
+        year = due_at.year
+        if month > 12:
+            month = 1
+            year += 1
+        day = min(due_at.day, calendar.monthrange(year, month)[1])
+        return due_at.replace(year=year, month=month, day=day)
+    return due_at
+
+
+def _format_local(dt: datetime, tz_name: str, *, all_day: bool = False) -> str:
+    try:
+        local = dt.astimezone(ZoneInfo(tz_name))
+    except Exception:
+        local = dt.astimezone(ZoneInfo("Europe/Moscow"))
+    if all_day:
+        return local.strftime("%Y-%m-%d")
+    return local.strftime("%Y-%m-%d %H:%M")
+
+
+class RemindersService:
+    def __init__(self, db: Session):
+        self.db = db
+
+    def _tz(self) -> str:
+        return resolve_timezone(self.db)
+
+    def _to_dict(self, row: Reminder) -> dict[str, Any]:
+        tz = row.timezone or self._tz()
+        return {
+            "id": row.id,
+            "title": row.title,
+            "notes": row.notes,
+            "due_at": row.due_at.isoformat(),
+            "due_at_local": _format_local(row.due_at, tz, all_day=row.all_day),
+            "all_day": row.all_day,
+            "recurrence": row.recurrence,
+            "enabled": row.enabled,
+            "completed_at": row.completed_at.isoformat() if row.completed_at else None,
+            "timezone": tz,
+            "created_at": row.created_at.isoformat() if row.created_at else None,
+        }
+
+    def snapshot(self) -> dict[str, Any]:
+        upcoming = self.list_upcoming(limit=12)
+        return {
+            "notify_seq": get_notify_seq(self.db),
+            "upcoming": upcoming,
+            "upcoming_count": len(upcoming),
+            "timezone": self._tz(),
+        }
+
+    def list_upcoming(self, *, limit: int = 30) -> list[dict[str, Any]]:
+        stmt = (
+            select(Reminder)
+            .where(
+                Reminder.enabled.is_(True),
+                Reminder.completed_at.is_(None),
+            )
+            .order_by(Reminder.due_at.asc())
+            .limit(limit)
+        )
+        return [self._to_dict(row) for row in self.db.scalars(stmt).all()]
+
+    def list_in_range(
+        self,
+        *,
+        date_from: datetime,
+        date_to: datetime,
+    ) -> list[dict[str, Any]]:
+        stmt = (
+            select(Reminder)
+            .where(
+                Reminder.enabled.is_(True),
+                Reminder.completed_at.is_(None),
+                Reminder.due_at >= date_from,
+                Reminder.due_at < date_to,
+            )
+            .order_by(Reminder.due_at.asc())
+        )
+        return [self._to_dict(row) for row in self.db.scalars(stmt).all()]
+
+    def get(self, reminder_id: int) -> dict[str, Any] | None:
+        row = self.db.get(Reminder, reminder_id)
+        return self._to_dict(row) if row else None
+
+    def create(
+        self,
+        *,
+        title: str,
+        due_at: str,
+        notes: str = "",
+        all_day: bool = False,
+        recurrence: str = RECURRENCE_NONE,
+    ) -> dict[str, Any]:
+        clean_title = title.strip()
+        if not clean_title:
+            raise ValueError("Название напоминания не может быть пустым")
+        rec = (recurrence or RECURRENCE_NONE).strip().lower()
+        if rec not in VALID_RECURRENCE:
+            raise ValueError(f"recurrence должен быть один из: {', '.join(sorted(VALID_RECURRENCE))}")
+
+        tz = self._tz()
+        due = _parse_due_at(due_at, tz)
+        row = Reminder(
+            title=clean_title,
+            notes=notes.strip(),
+            due_at=due,
+            all_day=all_day,
+            recurrence=rec,
+            timezone=tz,
+        )
+        self.db.add(row)
+        self.db.commit()
+        self.db.refresh(row)
+        bump_notify_seq(self.db)
+        return {"ok": True, "reminder": self._to_dict(row), "created": True}
+
+    def update(
+        self,
+        reminder_id: int,
+        *,
+        title: str | None = None,
+        due_at: str | None = None,
+        notes: str | None = None,
+        all_day: bool | None = None,
+        recurrence: str | None = None,
+        enabled: bool | None = None,
+    ) -> dict[str, Any]:
+        row = self.db.get(Reminder, reminder_id)
+        if not row:
+            raise ValueError("Напоминание не найдено")
+
+        if title is not None:
+            clean = title.strip()
+            if not clean:
+                raise ValueError("Название не может быть пустым")
+            row.title = clean
+        if notes is not None:
+            row.notes = notes.strip()
+        if due_at is not None:
+            row.due_at = _parse_due_at(due_at, row.timezone or self._tz())
+            row.last_fired_at = None
+        if all_day is not None:
+            row.all_day = all_day
+        if recurrence is not None:
+            rec = recurrence.strip().lower()
+            if rec not in VALID_RECURRENCE:
+                raise ValueError(f"recurrence должен быть один из: {', '.join(sorted(VALID_RECURRENCE))}")
+            row.recurrence = rec
+        if enabled is not None:
+            row.enabled = enabled
+
+        row.updated_at = _utcnow()
+        self.db.commit()
+        self.db.refresh(row)
+        bump_notify_seq(self.db)
+        return {"ok": True, "reminder": self._to_dict(row)}
+
+    def delete(self, reminder_id: int) -> dict[str, Any]:
+        row = self.db.get(Reminder, reminder_id)
+        if not row:
+            raise ValueError("Напоминание не найдено")
+        title = row.title
+        self.db.delete(row)
+        self.db.commit()
+        bump_notify_seq(self.db)
+        return {"ok": True, "deleted_id": reminder_id, "title": title}
+
+    def complete(self, reminder_id: int) -> dict[str, Any]:
+        row = self.db.get(Reminder, reminder_id)
+        if not row:
+            raise ValueError("Напоминание не найдено")
+        now = _utcnow()
+        row.completed_at = now
+        row.enabled = False
+        row.updated_at = now
+        self.db.commit()
+        self.db.refresh(row)
+        bump_notify_seq(self.db)
+        return {"ok": True, "reminder": self._to_dict(row)}

backend/app/reminders/watcher.py

@@ -0,0 +1,31 @@
+import asyncio
+import logging
+
+from app.config import get_settings
+from app.db.base import SessionLocal
+from app.reminders.fire import check_due_reminders
+
+logger = logging.getLogger(__name__)
+
+WATCH_INTERVAL_SEC = 30
+
+
+async def reminders_watcher_loop() -> None:
+    while True:
+        try:
+            await asyncio.sleep(WATCH_INTERVAL_SEC)
+            if not get_settings().reminders_enabled:
+                continue
+            await _tick()
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            logger.exception("Reminders watcher error")
+
+
+async def _tick() -> None:
+    db = SessionLocal()
+    try:
+        check_due_reminders(db)
+    finally:
+        db.close()