Files
buryan-agent 03d20b95db Агент по графу: понимает вопросы словами, без LLM
agent.py разбирает фразу в план (намерение, персона, жанр, тема, эпоха,
оценка) и выполняет запрос. Словарь берётся из графа, поэтому агент знает
только то, что есть в медиатеке.

Понимает русские синонимы (фантастика → science fiction, искусственный
интеллект → artificial intelligence, робот → robot) и транслитерацию имён
(«фильмы Нолана» → Christopher Nolan). Эпохи в любом виде, оценки по словам.

Пять намерений: подбор, фильмография, по десятилетиям, похожее, сравнение.
При пустом результате ослабляет условия по одному и сообщает об этом.
Показывает, как понял запрос.

Вызовы: команда «агент», свободный текст Медиа-бота, и «найди» с падением
в граф, когда в Jellyfin пусто.

Проверено: Нолан → Interstellar; ИИ по десятилетиям (1980-е 1, 1990-е 1,
2000-е 2, 2010-е 2); похоже на Дюну → 8 фильмов; высокорейтинговые 80-х →
Blade Runner; «найди про роботов с рейтингом» → 7 фильмов.

Попутно: /pick получил фильтры по персоне и оценке; /compare сравнивает
книгу и фильм (общие и разные жанры, автор, связь экранизации); поиск ядра
понимает русские окончания (Дюну → Dune).

Ловушки: явная команда первым словом (иначе «похоже» перехватывало запрос),
порог основы для коротких слов, и восстановление аналитических функций,
случайно срезанных при замене do_pick.
2026-10-20 11:39:22 +03:00

473 lines
20 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Минимальный клиент Matrix: отправка сообщений и длинный опрос."""
import json
import threading
import time
import urllib.parse
import urllib.request
class Matrix:
def __init__(self, homeserver, user_id, token):
self.hs = homeserver.rstrip("/")
self.user_id = user_id
self.token = token
self.txn = int(time.time() * 1000)
def _req(self, method, path, payload=None, timeout=40):
url = f"{self.hs}{path}"
headers = {"Authorization": f"Bearer {self.token}"}
data = None
if payload is not None:
data = json.dumps(payload).encode()
headers["Content-Type"] = "application/json"
req = urllib.request.Request(url, data=data, headers=headers, method=method)
try:
with urllib.request.urlopen(req, timeout=timeout) as r:
return json.loads(r.read() or b"{}")
except Exception as e:
return {"error": str(e)[:120]}
def send(self, room_id, text, formatted=None):
self.txn += 1
rid = urllib.parse.quote(room_id, safe="")
body = {"msgtype": "m.text", "body": text}
if formatted:
body["format"] = "org.matrix.custom.html"
body["formatted_body"] = formatted
return self._req("PUT", f"/_matrix/client/v3/rooms/{rid}/send/m.room.message/{self.txn}", body)
def send_chunked(self, room_id, text, limit=12000):
"""Matrix режет длинные сообщения — отправляем частями."""
if len(text) <= limit:
return self.send(room_id, text)
parts, buf = [], ""
for line in text.split("\n"):
if len(buf) + len(line) + 1 > limit:
parts.append(buf)
buf = line
else:
buf = f"{buf}\n{line}" if buf else line
if buf:
parts.append(buf)
for i, p in enumerate(parts):
prefix = f"({i + 1}/{len(parts)})\n" if len(parts) > 1 else ""
self.send(room_id, prefix + p)
return {"ok": True}
def set_typing(self, room_id, typing=True, timeout=15000):
rid = urllib.parse.quote(room_id, safe="")
return self._req("PUT", f"/_matrix/client/v3/rooms/{rid}/typing/{self.user_id}",
{"typing": typing, "timeout": timeout}, timeout=8)
def sync(self, since=None, timeout=30000):
params = {"timeout": str(timeout), "filter": json.dumps({"room": {"timeline": {"limit": 20}}})}
if since:
params["since"] = since
q = urllib.parse.urlencode(params)
return self._req("GET", f"/_matrix/client/v3/sync?{q}", timeout=timeout // 1000 + 20)
def join(self, room_id):
rid = urllib.parse.quote(room_id, safe="")
return self._req("POST", f"/_matrix/client/v3/join/{rid}", {})
def whoami(self):
return self._req("GET", "/_matrix/client/v3/account/whoami", timeout=10)
def create_dm(self, user_id, name=None):
"""Создаём личную комнату с человеком и приглашаем его."""
payload = {
"is_direct": True,
"preset": "trusted_private_chat",
"invite": [user_id],
}
if name:
payload["name"] = name
return self._req("POST", "/_matrix/client/v3/createRoom", payload, timeout=25)
def direct_rooms(self):
"""Что сервер считает личными комнатами (m.direct)."""
data = self._req("GET", "/_matrix/client/v3/user/" + urllib.parse.quote(self.user_id, safe="")
+ "/account_data/m.direct", timeout=10)
rooms = set()
if isinstance(data, dict):
for ids in data.values():
if isinstance(ids, list):
rooms.update(ids)
return rooms
_ENDINGS = ("ами", "ями", "ого", "его", "ому", "ему", "ыми", "ими", "ая", "яя",
"ое", "ее", "ые", "ие", "ой", "ый", "ий", "ам", "ям", "ах", "ях",
"ов", "ев", "а", "я", "у", "ю", "ы", "и", "е", "о", "ь")
def _stem(word):
"""Грубая основа слова: «статистику» → «статистик»."""
w = word.lower().replace("ё", "е")
for suf in _ENDINGS:
if len(w) > len(suf) + 3 and w.endswith(suf):
return w[: -len(suf)]
return w
class Bot:
"""Бот = учётка + набор команд. Отвечает в личке владельцу."""
name = "bot"
title = "Бот"
room_env = "ROOM"
# как люди называют команды обычными словами
ALIASES = {
"качается": "queue", "качают": "queue", "загружается": "queue",
"фотографии": "stats", "фото": "stats", "снимки": "stats",
"книги": "stats", "книга": "stats", "книг": "stats",
# уточняющие фразы (важнее одиночных слов)
"сколько места": "disk", "свободного места": "disk", "места осталось": "disk",
"что нового": "new", "как дела": "stats", "что сломалось": "status",
"кто заведен": "users", "кто в каких": "users",
"последний бэкап": "backups", "когда бэкап": "backups",
"продолжить просмотр": "resume", "что посмотреть": "resume",
"статистика": "stats", "стата": "stats", "сколько": "stats",
"новое": "new", "новинки": "new", "что нового": "new", "последнее": "new",
"поиск": "find", "найди": "find", "ищи": "find",
"сейчас": "now", "смотрят": "now",
"очередь": "queue", "закачки": "queue",
"заявки": "requests", "запросы": "requests",
"диск": "disk", "место": "disk",
"нехватка": "wanted", "не хватает": "wanted",
"файлы": "paths", "пути": "paths",
"карта": "map", "сводка": "digest", "дайджест": "digest",
"пробелы": "gaps", "чего не хватает": "gaps",
"службы": "services", "сервисы": "services",
"содержимое": "content", "контент": "content",
"тревоги": "alerts", "бэкапы": "backups", "бэкап": "backups",
"состояние": "status", "статус": "status",
"индекс": "index", "связи": "link",
"пространство": "space", "альбомы": "stats",
"помощь": "help", "команды": "help", "help": "help",
}
def __init__(self, mx, room_id, dm_rooms=None, owner=None):
self.mx = mx
self.room_id = room_id
self.dm_rooms = set(dm_rooms or [])
self.owner = owner
self.last_sender = None
self.commands = {}
self.register()
def cmd(self, name, help_text):
def deco(fn):
self.commands[name] = (help_text, fn)
return fn
return deco
def register(self):
pass
def help_text(self):
lines = [f"**{self.title}** — что я умею:", ""]
for name, (h, _) in sorted(self.commands.items()):
lines.append(f"• `!{name}` — {h}")
lines.append("")
lines.append("В личной переписке можно без восклицательного знака: "
"просто «статистика» или «найди дюна».")
return "\n".join(lines)
def _parse(self, text, in_dm):
"""Разбираем сообщение: команда, псевдоним или свободный текст.
Возвращает (команда|None, аргумент, исходный_текст).
"""
text = text.strip()
if not text:
return None, "", ""
low = text.lower().strip(" ?!.,")
if text.startswith("!"):
parts = text[1:].split(None, 1)
return parts[0].lower(), (parts[1] if len(parts) > 1 else ""), text
if not in_dm:
return None, "", text
# явная команда первым словом: «агент найди фильмы» → агент, а не «найди»
first = text.split(None, 1)
head = first[0].lower().strip(" ?!.,")
if head in self.commands:
rest = first[1] if len(first) > 1 else ""
return head, rest, text
# точное совпадение с псевдонимом или командой
if low in self.ALIASES:
return self.ALIASES[low], "", text
if low in self.commands:
return low, "", text
# по основам слов: «покажи статистику по медиа» → stats
# подбор по совпадению целых фраз: чем длиннее и точнее совпадение,
# тем выше шанс. Это чинит случаи вида «сколько места» → disk,
# где слово «сколько» само по себе значит stats.
stems = []
words = text.split()
for w in words:
clean = "".join(ch for ch in w.lower() if ch.isalnum())
if clean:
stems.append((_stem(clean), clean))
have = {st for st, _ in stems}
best = None
best_score = 0.0
best_pos = len(words)
candidates = list(self.ALIASES.items()) + [(c, c) for c in self.commands]
for phrase, cmd in candidates:
parts = [_stem(p) for p in phrase.split() if p.strip()]
if not parts or not all(p in have for p in parts):
continue
# вес: суммарная длина фразы, бонус за количество слов
score = sum(len(p) for p in parts) + 2.0 * len(parts)
# позиция первого слова фразы — для аргумента
pos = len(words)
for i, (st, _) in enumerate(stems):
if st == parts[0]:
pos = min(pos, i)
break
if score > best_score:
best, best_score, best_pos = cmd, score, pos
if best:
rest = " ".join(words[best_pos + 1:]).strip()
return best, rest, text
# не команда — это просьба или вопрос к владельцу
return None, "", text
def _onboard(self, sender):
"""Первый раз от этого человека — прислать инструкцию по направлению."""
try:
import json, os
path = "/var/lib/hub-bots/onboarded.json"
os.makedirs(os.path.dirname(path), exist_ok=True)
try:
data = json.load(open(path, encoding="utf-8"))
except OSError:
data = {}
key = f"{self.name}:{sender}"
if data.get(key):
return None
data[key] = True
json.dump(data, open(path, "w", encoding="utf-8"), ensure_ascii=False, indent=1)
from . import guides
return guides.render(self.name)
except Exception:
return None
def dispatch(self, text, in_dm=False):
cmd, arg, raw = self._parse(text, in_dm)
if (cmd is None and raw.lower().startswith("export")) or cmd == "export":
return self._export((raw[6:].strip() if raw.lower().startswith("export") else arg))
if cmd is None:
if not in_dm:
return None
routed = self._llm_route(raw)
if routed:
return routed
return self.handle_freeform(raw)
if cmd in ("help", "помощь", "?", "start"):
try:
from . import guides
guide = guides.render(self.name)
if guide:
return guide
except Exception:
pass
return self.help_text()
if cmd not in self.commands:
близко = ", ".join(f"`!{c}`" for c in sorted(self.commands)[:6])
return f"Не знаю команду `{cmd}`. Есть: {близко}. Подробнее — `!help`."
try:
return self.commands[cmd][1](arg) or "Готово."
except Exception as e:
return f"Ошибка при `{cmd}`: {str(e)[:200]}"
def _llm_route(self, text):
"""Свободная фраза: спрашиваем модель, что вызвать."""
try:
from . import llm
except Exception:
return None
if not llm.enabled():
return None
res = llm.route(self, text)
if not res:
return None
kind, *rest = res
if kind == "tool":
name, arg = rest[0], rest[1]
try:
return self.commands[name][1](arg) or "Готово."
except Exception as e:
return f"Ошибка при вызове {name}: {str(e)[:150]}"
if kind == "answer":
answer = rest[0]
if not answer:
return None
self._remember(text, answer)
return answer
return None
def _remember(self, question, answer):
"""Пишем диалог в журнал — пригодится для разбора."""
try:
import json, os, datetime
path = "/var/lib/hub-bots/dialog.jsonl"
os.makedirs(os.path.dirname(path), exist_ok=True)
with open(path, "a", encoding="utf-8") as f:
f.write(json.dumps({"at": datetime.datetime.now().isoformat(timespec="seconds"),
"bot": self.name, "q": question[:500],
"a": answer[:500]}, ensure_ascii=False) + "\n")
except Exception:
pass
def handle_freeform(self, text):
"""Свободный текст: сначала агент по графу, потом владельцу."""
if self.name == "media":
low = (text or "").lower()
hints = ("найди", "посовет", "подбери", "что посмотреть", "сравн",
"похож", "когда", "фильмограф", "кто снимал", "покажи")
if any(h in low for h in hints):
try:
from . import agent as graph_agent
answer, plan = graph_agent.run(text)
steps = graph_agent.describe(plan)
return answer + chr(10) + chr(10) + "_понял так: " + steps + "_"
except Exception:
pass
from . import inbox
num = inbox.add(self.name, self.last_sender or "?", text)
if num is None:
return "Принял, но сегодня уже слишком много сообщений. Попробуйте завтра."
self._export_data("wishes", {
"от": self.last_sender or "неизвестно",
"бот": self.name,
"номер": num,
"текст": text[:1000],
}, tags=["пожелание"])
self.notify_owner(text, num)
return (f"Принял: «{text[:200]}»\n\n"
f"Это не команда, поэтому передал владельцу и агенту — "
f"запись №{num}. Ответ придёт, когда её посмотрят.")
def _export_data(self, collection, payload, tags=None):
"""Отправить данные в ядро — они лягут в папку проекта."""
try:
from . import core_api
import hashlib, time
key = hashlib.sha1(
(self.name + str(payload) + str(time.time())).encode()).hexdigest()[:16]
core_api.save_data(collection, key, payload, tags or [])
return True
except Exception:
return False
def _export(self, arg):
"""Выгрузить коллекцию в папку проекта."""
from . import core_api
collection = (arg or "").strip() or "wishes"
data, err = core_api.export_data(collection, "md")
if err:
return f"Не получилось выгрузить: {err}"
return (f"Выгружено в папку проекта:\n`{data.get('path')}`\n"
f"записей: {data.get('count')}")
def notify_owner(self, text, num):
"""Копия просьбы уходит владельцу, чтобы её не потерять."""
owner = self.owner
if not owner or owner in self.dm_rooms:
return
try:
dm = self.mx.create_dm(owner)
rid = dm.get("room_id")
if rid:
self.mx.join(rid)
self.dm_rooms.add(rid)
self.mx.send_chunked(
rid,
f"**Просьба от {self.last_sender or '?'}** (запись №{num})\n\n{text[:1500]}")
except Exception:
pass
def poll_loop(bot, stop_event, on_ready=None, allowed=None):
"""Слушаем только личные комнаты и только разрешённых людей.
Пока идёт проверка, писать боту может только владелец. Остальным —
вежливый отказ (чтобы не выглядело поломкой).
"""
since = None
first = True
allowed = set(allowed or [])
while not stop_event.is_set():
try:
resp = bot.mx.sync(since=since, timeout=25000)
if "error" in resp:
time.sleep(5)
continue
since = resp.get("next_batch", since)
if first:
first = False
try:
bot.dm_rooms |= bot.mx.direct_rooms()
except Exception:
pass
if on_ready:
on_ready(bot)
continue
rooms = resp.get("rooms", {}).get("join", {})
# приглашение в личку принимаем, если это прямой чат
for rid, invite in (resp.get("rooms", {}).get("invite") or {}).items():
try:
bot.mx.join(rid)
is_direct = any(
ev.get("type") == "m.room.member" and ev.get("content", {}).get("is_direct")
for ev in (invite.get("invite_state", {}) or {}).get("events", []))
if is_direct:
bot.dm_rooms.add(rid)
except Exception:
pass
for rid, data in rooms.items():
if rid not in bot.dm_rooms:
continue
for ev in data.get("timeline", {}).get("events", []):
if ev.get("type") != "m.room.message":
continue
sender = ev.get("sender")
if sender == bot.mx.user_id:
continue
body = ev.get("content", {}).get("body", "")
if not body:
continue
if allowed and sender not in allowed:
bot.mx.send_chunked(
rid,
"Сейчас я на проверке и отвечаю только владельцу. "
"Как только откроют общий доступ — напишу.")
continue
bot.last_sender = sender
intro = bot._onboard(sender)
if intro:
bot.mx.send_chunked(rid, intro)
reply = bot.dispatch(body, in_dm=True)
if reply:
bot.mx.set_typing(rid, False)
bot.mx.send_chunked(rid, reply)
except Exception:
time.sleep(5)