435 lines
18 KiB
Python
Executable File
435 lines
18 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
"""Рабочий секретарь v2: диалог + напоминания.
|
|
|
|
Свободный текст -> LLM-агент (правит задачи). Команды и напоминания —
|
|
локально, без обращения к модели.
|
|
"""
|
|
import datetime as dt
|
|
import os
|
|
import re
|
|
import sys
|
|
import time
|
|
import traceback
|
|
|
|
sys.path.insert(0, "/opt/work-hub")
|
|
|
|
import agent
|
|
import caldav
|
|
import parse
|
|
import store
|
|
from matrix import Matrix
|
|
|
|
TYPES_RU = {
|
|
"демо": "демо-фонд", "баг": "прошивка/баг", "тз": "ТЗ", "описание": "техописание",
|
|
"проект": "проект оборудования", "встреча": "встреча", "пресейл": "пресейл",
|
|
"помощь": "внутренняя помощь", "прочее": "прочее",
|
|
}
|
|
|
|
WEEKDAYS = {"понедельник": 0, "вторник": 1, "среду": 2, "среда": 2, "четверг": 3,
|
|
"пятницу": 4, "пятница": 4, "субботу": 5, "суббота": 5, "воскресенье": 6}
|
|
|
|
|
|
def env():
|
|
d = {}
|
|
for line in open("/opt/work-hub/bot.env", encoding="utf-8"):
|
|
line = line.strip()
|
|
if not line or line.startswith("#") or "=" not in line:
|
|
continue
|
|
k, v = line.split("=", 1)
|
|
d[k] = v
|
|
os.environ.setdefault(k, v) # чтобы caldav видел CALDAV_*
|
|
return d
|
|
|
|
|
|
def fmt_item(it):
|
|
due = it.get("due") or "без срока"
|
|
prt = (" · " + it["partner"]) if it.get("partner") else ""
|
|
return "#%d %s [%s%s, %s]" % (it["id"], (it["text"] or "")[:120],
|
|
TYPES_RU.get(it.get("type"), it.get("type")), prt, due)
|
|
|
|
|
|
def fmt_rem(r):
|
|
when = dt.datetime.fromtimestamp(r["fire_at"]).strftime("%d.%m %H:%M")
|
|
subj = r.get("item_text") or r.get("text") or ""
|
|
return "%s — %s" % (when, subj[:90])
|
|
|
|
|
|
def help_text():
|
|
return ("Пишите свободно — веду список дел и правлю его по ходу.\n"
|
|
"Уточнения применяю к существующей задаче, новую создаю только на новое дело.\n\n"
|
|
"список · статус · сводка · напоминания\n"
|
|
"готово 12 · перенеси 12 на пятницу\n"
|
|
"напомни через 2 часа про #3 · напомни завтра в 10 · напомни в пятницу в 9\n"
|
|
"покажи 3 · помощь")
|
|
|
|
|
|
def digest_text(mode="morning"):
|
|
today = dt.date.today()
|
|
iso = today.isoformat()
|
|
s = store.stats()
|
|
if mode == "evening":
|
|
border = int(time.time()) - 12 * 3600
|
|
with store.db() as c:
|
|
done = [dict(r) for r in c.execute(
|
|
"select * from items where status='done' and done_ts>? order by done_ts", (border,))]
|
|
lines = ["Вечер, %s" % today.strftime("%d.%m"), "", "Сделано за день: %d" % len(done)]
|
|
for d in done[:10]:
|
|
lines.append(" ✓ " + (d["text"] or "")[:90])
|
|
tm = store.due_between((today + dt.timedelta(days=1)).isoformat(),
|
|
(today + dt.timedelta(days=1)).isoformat())
|
|
if tm:
|
|
lines += ["", "На завтра:"]
|
|
lines += [" • " + fmt_item(x) for x in tm]
|
|
rem = store.pending_reminders(5)
|
|
if rem:
|
|
lines += ["", "Напоминания:"]
|
|
lines += [" ⏰ " + fmt_rem(r) for r in rem]
|
|
lines += ["", "Открыто всего: %d" % s["open"]]
|
|
return "\n".join(lines)
|
|
|
|
lines = ["Утро, %s" % today.strftime("%d.%m"), ""]
|
|
td = store.due_between(iso, iso)
|
|
od = store.overdue(iso)
|
|
st = store.stuck(3)
|
|
lines.append("На сегодня: %d" % len(td))
|
|
for x in td:
|
|
lines.append(" • " + fmt_item(x))
|
|
if od:
|
|
lines += ["", "Просрочено: %d" % len(od)] + [" ! " + fmt_item(x) for x in od[:10]]
|
|
rem = store.pending_reminders(7)
|
|
if rem:
|
|
lines += ["", "Напоминания:"] + [" ⏰ " + fmt_rem(r) for r in rem]
|
|
if st:
|
|
lines += ["", "Висит без срока: %d" % len(st)] + [" … " + fmt_item(x) for x in st[:7]]
|
|
if not (td or od or st):
|
|
lines.append("Пусто — ни сроков, ни зависших.")
|
|
lines += ["", "Открыто всего: %d" % s["open"]]
|
|
return "\n".join(lines)
|
|
|
|
|
|
def parse_when(text, now=None):
|
|
"""Когда напомнить: 'через 2 часа', 'завтра в 10', 'в пятницу в 14:30', '05.11 в 9'."""
|
|
now = now or dt.datetime.now()
|
|
t = (text or "").lower()
|
|
|
|
m = re.search(r"через\s+(\d{1,3})\s*(мин|час|дн|день|дня|недел)", t)
|
|
if m:
|
|
n = int(m.group(1))
|
|
unit = m.group(2)
|
|
if unit.startswith("мин"):
|
|
return now + dt.timedelta(minutes=n)
|
|
if unit.startswith("час"):
|
|
return now + dt.timedelta(hours=n)
|
|
if unit.startswith("недел"):
|
|
return now + dt.timedelta(weeks=n)
|
|
return now + dt.timedelta(days=n)
|
|
|
|
m = re.search(r"в\s+(\d{1,2})(?::(\d{2}))?", t)
|
|
hh = int(m.group(1)) if m else 9
|
|
mm = int(m.group(2)) if (m and m.group(2)) else 0
|
|
if hh > 23:
|
|
hh = 9
|
|
|
|
base = None
|
|
if "завтра" in t:
|
|
base = now.date() + dt.timedelta(days=1)
|
|
elif "сегодня" in t:
|
|
base = now.date()
|
|
else:
|
|
for name, wd in WEEKDAYS.items():
|
|
if name in t:
|
|
delta = (wd - now.weekday()) % 7 or 7
|
|
base = now.date() + dt.timedelta(days=delta)
|
|
break
|
|
if base is None:
|
|
m2 = re.search(r"\b(\d{1,2})[.\-/](\d{1,2})\b", t)
|
|
if m2:
|
|
try:
|
|
base = dt.date(now.year, int(m2.group(2)), int(m2.group(1)))
|
|
except ValueError:
|
|
base = None
|
|
|
|
when = dt.datetime.combine(base, dt.time(hh, mm)) if base else None
|
|
if when and when < now:
|
|
if base and base == now.date():
|
|
when += dt.timedelta(days=1)
|
|
return when
|
|
|
|
|
|
def handle_remind(text):
|
|
m = re.match(r"(?i)^напомн\w*\s+(.*)$", text.strip())
|
|
if not m:
|
|
return None
|
|
rest = m.group(1)
|
|
when = parse_when(rest)
|
|
if not when:
|
|
return ("Не понял когда. Примеры: «напомни через 2 часа про #3», "
|
|
"«напомни завтра в 10», «напомни в пятницу в 9».")
|
|
idm = re.search(r"#?\b(\d{1,4})\b", rest)
|
|
item_id = None
|
|
subj = rest
|
|
if idm:
|
|
cand = int(idm.group(1))
|
|
if store.get(cand):
|
|
item_id = cand
|
|
subj = (store.get(cand)["text"] or "")[:120]
|
|
rid = store.add_reminder(when.timestamp(), subj, item_id)
|
|
return "Напомню %s: %s" % (when.strftime("%d.%m в %H:%M"), subj[:110])
|
|
|
|
|
|
def check_reminders(mx, room):
|
|
for r in store.due_reminders():
|
|
subj = r.get("text") or ""
|
|
if r.get("item_id"):
|
|
it = store.get(r["item_id"])
|
|
if it and it.get("status") == "done":
|
|
store.mark_reminder_sent(r["id"])
|
|
continue
|
|
if it:
|
|
subj = it["text"] or subj
|
|
mx.send(room, "⏰ Напоминание: " + (subj or "без текста")[:300])
|
|
store.mark_reminder_sent(r["id"])
|
|
|
|
|
|
|
|
def sync_item(iid):
|
|
"""Зеркалит задачу в Nextcloud (список «Работа»)."""
|
|
try:
|
|
it = store.get(iid)
|
|
if it and it.get("type") == "встреча":
|
|
return
|
|
if it:
|
|
caldav.put_todo(it, done=(it.get("status") == "done"))
|
|
else:
|
|
caldav.delete_todo(iid)
|
|
except Exception as e:
|
|
print("caldav:", e, flush=True)
|
|
|
|
|
|
def apply_actions(actions):
|
|
touched = []
|
|
for a in actions:
|
|
op = a.get("op")
|
|
if op == "create":
|
|
payload = {"type": a.get("type") or "прочее",
|
|
"partner": a.get("partner") or None, "due": a.get("due") or None}
|
|
if payload["due"]:
|
|
try:
|
|
dt.date.fromisoformat(payload["due"])
|
|
except Exception:
|
|
payload["due"] = None
|
|
touched.append(store.add_item((a.get("text") or "").strip(), payload))
|
|
elif op == "update":
|
|
iid = int(a.get("id") or 0)
|
|
if iid and store.get(iid):
|
|
fields = a.get("fields") or {}
|
|
if fields.get("due"):
|
|
try:
|
|
dt.date.fromisoformat(fields["due"])
|
|
except Exception:
|
|
fields.pop("due", None)
|
|
store.update_item(iid, fields)
|
|
touched.append(iid)
|
|
elif op == "done":
|
|
iid = int(a.get("id") or 0)
|
|
if iid and store.get(iid):
|
|
store.set_status(iid, "done")
|
|
touched.append(iid)
|
|
elif op == "delete":
|
|
iid = int(a.get("id") or 0)
|
|
if iid and store.get(iid):
|
|
store.delete_item(iid)
|
|
touched.append(iid)
|
|
elif op == "event":
|
|
import datetime as _dt
|
|
start_s = (a.get("start") or "").strip()
|
|
start = None
|
|
for fmt in ("%Y-%m-%dT%H:%M", "%Y-%m-%dT%H:%M:%S", "%Y-%m-%d %H:%M",
|
|
"%d.%m.%Y %H:%M", "%d.%m %H:%M", "%Y-%m-%dT%H:%M:%S%z"):
|
|
try:
|
|
start = _dt.datetime.strptime(start_s, fmt)
|
|
break
|
|
except Exception:
|
|
continue
|
|
if start is None:
|
|
try:
|
|
start = _dt.datetime.fromisoformat(start_s)
|
|
except Exception:
|
|
start = None
|
|
if start is None:
|
|
payload = {"type": "встреча", "partner": a.get("partner") or None, "due": None}
|
|
iid = store.add_item((a.get("text") or "Встреча").strip(), payload)
|
|
touched.append(iid)
|
|
if start:
|
|
payload = {"type": "встреча", "partner": a.get("partner") or None,
|
|
"due": start.date().isoformat()}
|
|
iid = store.add_item((a.get("text") or "Встреча").strip(), payload)
|
|
end = start + _dt.timedelta(hours=int(a.get("hours") or 1))
|
|
try:
|
|
caldav.put_event(store.get(iid), start, end, a.get("place"))
|
|
except Exception as e:
|
|
print("caldav event:", e, flush=True)
|
|
touched.append(iid)
|
|
for i in touched:
|
|
sync_item(i)
|
|
return touched
|
|
|
|
|
|
def handle(text, room, mx):
|
|
t = (text or "").strip()
|
|
low = t.lower()
|
|
if not t:
|
|
return None
|
|
|
|
if low in ("помощь", "/help", "help", "что ты умеешь"):
|
|
return help_text()
|
|
if low in ("список", "/список", "что в работе", "задачи"):
|
|
items = store.open_items(30)
|
|
return ("Открытых задач нет." if not items else
|
|
"Открытые задачи (%d):\n" % len(items) + "\n".join(fmt_item(i) for i in items))
|
|
if low in ("напоминания", "напоминалки"):
|
|
rem = store.pending_reminders(20)
|
|
return ("Напоминаний нет." if not rem else
|
|
"Напоминания (%d):\n" % len(rem) + "\n".join("⏰ " + fmt_rem(r) for r in rem))
|
|
if low in ("статус", "/статус"):
|
|
today = dt.date.today().isoformat()
|
|
st = store.stats()
|
|
return ("Открыто: %d · на сегодня: %d · просрочено: %d · напоминаний: %d\n"
|
|
"Сообщений записано: %d" % (st["open"], len(store.due_between(today, today)),
|
|
len(store.overdue(today)), len(store.pending_reminders(50)),
|
|
st["messages"]))
|
|
if low in ("сводка", "/сводка"):
|
|
return digest_text("morning")
|
|
if low in ("синк", "синхронизируй", "в nextcloud"):
|
|
items = store.open_items(100)
|
|
ok = 0
|
|
for it in items:
|
|
if caldav.put_todo(it) in (200, 201, 204):
|
|
ok += 1
|
|
return "Отправлено в Nextcloud (список «Работа»): %d из %d" % (ok, len(items))
|
|
|
|
if low.startswith("напомн"):
|
|
return handle_remind(t)
|
|
|
|
m = re.match(r"(?i)^(покажи|открой|что по)\s+(?:задач[уи])?\s*#?(\d{1,4})$", t)
|
|
if m:
|
|
it = store.get(int(m.group(2)))
|
|
if not it:
|
|
return "Задачи #%s нет." % m.group(2)
|
|
return fmt_item(it) + ("\nСтатус: " + it["status"])
|
|
|
|
if low.startswith(("готово ", "сделано ", "выполнено ")) or (low.startswith("+") and any(ch.isdigit() for ch in low)):
|
|
num = next(("".join(ch for ch in p if ch.isdigit()) for p in t.split() if any(ch.isdigit() for ch in p)), "")
|
|
if not num:
|
|
return "Не понял номер. Пример: готово 12"
|
|
iid = int(num)
|
|
if not store.get(iid):
|
|
return "Задачи #%d нет." % iid
|
|
store.set_status(iid, "done")
|
|
sync_item(iid)
|
|
return "Отмечено выполненным: #%d" % iid
|
|
|
|
if low.startswith("перенеси"):
|
|
num = next(("".join(ch for ch in p if ch.isdigit()) for p in t.split() if any(ch.isdigit() for ch in p)), "")
|
|
if not num:
|
|
return "Не понял номер. Пример: перенеси 12 на пятницу"
|
|
iid = int(num)
|
|
if not store.get(iid):
|
|
return "Задачи #%d нет." % iid
|
|
due = parse.parse_due(t)
|
|
if not due:
|
|
return "Не понял новый срок. Пример: перенеси 12 на пятницу"
|
|
store.set_due(iid, due.isoformat())
|
|
sync_item(iid)
|
|
return "Задача #%d теперь на %s" % (iid, due.strftime("%d.%m"))
|
|
|
|
|
|
# Встречи разбираем детерминированно, без модели: дата/время + слово-триггер.
|
|
if any(k in low for k in ("встреча", "созвон", "приезд", "приеду", "демо в", "покажу в", "созвонимся")):
|
|
start = parse_when(t)
|
|
if start:
|
|
payload = {"type": "встреча", "partner": parse.parse_partner(t),
|
|
"due": start.date().isoformat()}
|
|
iid = store.add_item(t, payload)
|
|
end = start + dt.timedelta(hours=1)
|
|
try:
|
|
caldav.put_event(store.get(iid), start, end, None)
|
|
except Exception as e:
|
|
print("caldav event:", e, flush=True)
|
|
return ("Встреча #%d: %s — %s. Записал в календарь «Работа»."
|
|
% (iid, start.strftime("%d.%m в %H:%M"), t[:100]))
|
|
|
|
items = store.open_items(20)
|
|
history = store.recent_messages(4)
|
|
reply, actions = agent.respond(t, items, history)
|
|
if reply is None and (not actions or actions[0].get("op") == "error"):
|
|
p = parse.parse(t)
|
|
iid = store.add_item(t, p)
|
|
sync_item(iid)
|
|
return ("Модель недоступна, записал по правилам: #%d (%s)." % (iid, TYPES_RU.get(p["type"], p["type"])))
|
|
touched = apply_actions(actions or [])
|
|
out = reply or "Записал."
|
|
if touched:
|
|
out += "\nЗатронуто: " + ", ".join("#%d" % i for i in touched)
|
|
return out
|
|
|
|
|
|
def loop():
|
|
cfg = env()
|
|
mx = Matrix(cfg["MATRIX"], cfg["WORK_TOKEN"], cfg["WORK_USER"])
|
|
owner = cfg["OWNER"]
|
|
room = cfg["WORK_ROOM"]
|
|
store.init()
|
|
mx.join(room)
|
|
print("секретарь v2 (диалог+напоминания) в комнате", room, flush=True)
|
|
|
|
started_ms = int(time.time() * 1000)
|
|
seen = set()
|
|
since = None
|
|
while True:
|
|
try:
|
|
check_reminders(mx, room)
|
|
data = mx.sync(since)
|
|
since = data.get("next_batch") or since
|
|
for rid, rdata in ((data.get("rooms") or {}).get("join") or {}).items():
|
|
for ev in (rdata.get("timeline") or {}).get("events") or []:
|
|
if ev.get("type") != "m.room.message":
|
|
continue
|
|
if ev.get("sender") != owner:
|
|
continue
|
|
eid = ev.get("event_id") or ""
|
|
if eid in seen:
|
|
continue
|
|
seen.add(eid)
|
|
if int(ev.get("origin_server_ts") or 0) < started_ms - 3000:
|
|
continue
|
|
body = (ev.get("content") or {}).get("body") or ""
|
|
store.log_message(rid, ev.get("sender"), body)
|
|
try:
|
|
reply = handle(body, rid, mx)
|
|
except Exception:
|
|
reply = "Сбой обработки, сообщение сохранено:\n" + traceback.format_exc()[-300:]
|
|
if reply:
|
|
mx.send(rid, reply)
|
|
check_reminders(mx, room)
|
|
except Exception as e:
|
|
print("sync:", e, flush=True)
|
|
time.sleep(5)
|
|
|
|
|
|
def main():
|
|
if len(sys.argv) > 1 and sys.argv[1] == "digest":
|
|
cfg = env()
|
|
mx = Matrix(cfg["MATRIX"], cfg["WORK_TOKEN"], cfg["WORK_USER"])
|
|
mode = "evening" if dt.datetime.now().hour >= 15 else "morning"
|
|
check_reminders(mx, cfg["WORK_ROOM"])
|
|
mx.send(cfg["WORK_ROOM"], digest_text(mode))
|
|
return
|
|
store.init()
|
|
loop()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|