Compare commits
10
Commits
main
..
6ff0da31a3
| Author | SHA1 | Date | |
|---|---|---|---|
 hh
|
6ff0da31a3 | ||
|
hh
|
7af833a4d7 | ||
|
hh
|
03ed732f7a | ||
|
hh
|
03774c54e3 | ||
|
hh
|
71af41f35f | ||
|
hh
|
ef5adf231a | ||
|
hh
|
62b8b1c14b | ||
|
hh
|
91c638186b | ||
 hhandClaude Fable 5
|
95fc8a4578 | ||
|
hhandClaude Fable 5
|
a937500d9b |
No files matched your search
+12
-71
@@ -5,9 +5,8 @@
|
||||
|
||||
### Compose ###################################################################
|
||||
|
||||
# Какие сервисы поднимать: db (postgres), gateway, obsidian (obsidian-headless),
|
||||
# t3 (t3code-mcp - руки диспетчера на маке и dell-dev), vibegram (клон репы комнаты)
|
||||
COMPOSE_PROFILES=db,gateway,obsidian,t3,vibegram
|
||||
# Какие сервисы поднимать: db (postgres), gateway, obsidian (obsidian-headless)
|
||||
COMPOSE_PROFILES=db,gateway,obsidian
|
||||
|
||||
# Ветка/тег beaver-gateway, из которого собирается образ шлюза
|
||||
GATEWAY_REF=main
|
||||
@@ -31,11 +30,6 @@ ADMIN_PASS=
|
||||
# Подпись session-cookie admin UI
|
||||
SESSION_SECRET=
|
||||
|
||||
# Мастер-ключ хранилища секретов (admin → System → Secrets): openssl rand -hex 32.
|
||||
# Шифрует таблицу secrets в postgres, поэтому дамп базы без него закрыт.
|
||||
# В env модели не попадает. Потерян или сменён - секреты задаются заново.
|
||||
SECRETS_KEY=
|
||||
|
||||
### Claude ####################################################################
|
||||
|
||||
# OAuth-токен подписки для Claude Agent SDK внутри контейнера.
|
||||
@@ -59,88 +53,35 @@ RAYCAST_DEVICE_ID=
|
||||
# rca_... из десктоп-приложения Raycast (см. raycast-api)
|
||||
RAYCAST_BEARER=
|
||||
|
||||
### Отдача файлов человеку (send_file) ########################################
|
||||
|
||||
# Откуда тулза send_file имеет право брать файлы (несколько - через ':').
|
||||
# Папка входящих вложений разрешена всегда, её дописывает сам фронтенд.
|
||||
# Каталог должен быть виден контейнеру gateway по ТОМУ ЖЕ пути, что снаружи
|
||||
# (см. монтирование /mnt/hole/shared в docker-compose.yml).
|
||||
# Пусто = /mnt/hole/shared, дефолт шлюза
|
||||
SEND_FILE_ROOTS=/mnt/hole/shared
|
||||
|
||||
### MCP, к которым ходят агенты ###############################################
|
||||
|
||||
# Firefly III: адрес и Personal Access Token
|
||||
FIREFLY_BASE_URL=
|
||||
FIREFLY_PAT=
|
||||
# Календари: name=url,name=url (пусто - без календарей).
|
||||
# В url лежит приватный ical-фид (google `/private-<токен>/`, usos `key=`) -
|
||||
# это секрет: утёк url = утёк календарь, лечится перевыпуском фида.
|
||||
# Модели календари даются MCP-руками, а справка конверта раз в день читает
|
||||
# тот же ical напрямую - урл фида она берёт из параметра `icsUrl` этих же
|
||||
# записей; записи без `icsUrl` остаются рукой, но в справку не попадают.
|
||||
# Календари: name=url,name=url (пусто - без календарей)
|
||||
CALENDAR_MCPS=
|
||||
# MCP beavergram (telegram-history)
|
||||
BEAVERGRAM_MCP=
|
||||
# MCP msos (таскер рабочих проектов): полный URL с токеном, https://…/mcp?token=…
|
||||
MSOS_MCP=
|
||||
|
||||
### t3code (руки диспетчера, с S10) ###########################################
|
||||
|
||||
# t3code-mcp - сервис compose (профиль t3), машины и allowlist - ./t3code.toml.
|
||||
# На каждой машине: `t3 auth session issue --token-only --ttl 365d --label beaver`
|
||||
T3_MAC_TOKEN=
|
||||
T3_DELL_DEV_TOKEN=
|
||||
# tailnet-адрес dell-dev (дев-VM на делле), прописывается контейнеру в hosts
|
||||
T3_DELL_DEV_ADDR=
|
||||
# Токен gateway со scope `api` (admin → Tokens) - им t3code-mcp шлёт события в /hooks/t3code
|
||||
T3CODE_MCP_GATEWAY_TOKEN=
|
||||
# Ветка/тег t3code-mcp, из которого собирается образ
|
||||
T3CODE_MCP_REF=main
|
||||
# `t3 serve --tailscale-serve --host <tailnet-ip>` на маке → адрес
|
||||
T3_URL=
|
||||
# `t3 auth session issue --token-only`
|
||||
T3_TOKEN=
|
||||
|
||||
### Komodo (python_tool с перечисленными действиями, с S8) ####################
|
||||
|
||||
KOMODO_URL=
|
||||
KOMODO_KEY=
|
||||
KOMODO_SECRET=
|
||||
# Алерты Komodo → /hooks/komodo?token=<секрет> (алертер в infra/komodo, Custom
|
||||
# endpoint; Komodo не умеет заголовки). Секрет - существующий Komodo Secret
|
||||
# (тот же, что у healthbot); gateway принимает его bootstrap-токеном со scope api:
|
||||
#BOOTSTRAP_TOKENS=komodo-hook:<значение секрета>:api
|
||||
|
||||
### Home Assistant (python_tool, с S12) ########################################
|
||||
|
||||
# HA на том же хосте с network_mode: host → host.docker.internal (extra_hosts)
|
||||
HA_URL=http://host.docker.internal:8123
|
||||
# Профиль → Безопасность → долгоживущие токены
|
||||
HA_TOKEN=
|
||||
|
||||
### Вайбграм (комната агентов, с S12) #########################################
|
||||
|
||||
# Хаб и токен агента: один раз `vibegram join <code> --nick <ник> --no-hooks`
|
||||
# из клона репы комнаты на любой машине, токен - в ~/.vibegram/config.json
|
||||
VIBEGRAM_HUB=
|
||||
VIBEGRAM_TOKEN=
|
||||
VIBEGRAM_NICK=
|
||||
# Репа комнаты (GitHub org/repo) - сервис vibegram-repo держит клон в томе
|
||||
# `vibegram`, gateway видит его в /vibegram/<repo> только на чтение
|
||||
VIBEGRAM_REPO=
|
||||
# Токен GitHub с доступом к репе (приватная); пусто - публичная
|
||||
VIBEGRAM_REPO_TOKEN=
|
||||
|
||||
VIBEGRAM_HB_TOKEN=
|
||||
VIBEGRAM_HB_NICK=
|
||||
|
||||
### Досуг (ежечасный тик мастера, с S13) ######################################
|
||||
|
||||
# Час активного окна (12:00-03:59) и четыре часа тихого (04:00-11:59) будят
|
||||
# мастера инжектом без задания. Повседневный выключатель - строка `досуг: выкл`
|
||||
# в `мета/бобер/досуг.md`; здесь - рубильник: `off` снимает джоб совсем.
|
||||
# Пусто = включено.
|
||||
LEISURE=
|
||||
|
||||
### Порты хоста и внешний адрес ###############################################
|
||||
|
||||
PORT_GATEWAY=62990
|
||||
PORT_MESSAGES=62990
|
||||
PORT_MCP=62991
|
||||
PORT_ADMIN=62992
|
||||
PORT_MARKDOWN=62993
|
||||
PORT_API=62994
|
||||
# Публичный URL за reverse proxy (см. ./caddy). Пусто для localhost/dev
|
||||
PUBLIC_BASE_URL=
|
||||
@@ -4,4 +4,3 @@ config.json
|
||||
__pycache__/
|
||||
.idea
|
||||
docker-compose.override.yml
|
||||
scripts/seed_out/
|
||||
@@ -7,7 +7,6 @@ check:
|
||||
uv run ruff format --check
|
||||
uv run ruff check
|
||||
uv run ty check
|
||||
uv run pytest -q
|
||||
|
||||
fix:
|
||||
uv run ruff format
|
||||
|
||||
@@ -1,10 +1,8 @@
|
||||
# beaver-agent
|
||||
|
||||
My real [beaver-gateway](https://git.kotikot.com/beaver/beaver-gateway) setup: the Beavering Manager, a personal agent that lives on a home server, reads an Obsidian vault, talks through Telegram and deep chats in the vault, remembers people and promises, and has hands (Komodo, Home Assistant, T3 Code threads, calendars, Firefly, Telegram history through beavergram). The narrative and the docs are on [the site](https://beaver.kotikot.com/docs); this README is the operator's part: how to run it.
|
||||
My real beaver-gateway setup (paired with the protocol from beaver.kotikot.com).
|
||||
|
||||
Uses Claude Code and Raycast subscriptions for agents, has some MCPs set up. You can use this as-is or modify to match your needs: `config.py` assembles the gateway from the `beaver_agent/` package. It is opinion, not core - every piece is meant to be rewritten for your own vault.
|
||||
|
||||
Seeding memory from an existing vault (old chats into digests, diary days and thoughts into notes about people) is one run of `scripts/seed_memory.py`; `--dry-run` first.
|
||||
Uses Claude Code and Raycast subscriptions for agents, has some MCPs set up. You can use this as-is or modify to match your needs (config.py).
|
||||
|
||||
## Requirements
|
||||
|
||||
@@ -62,24 +60,15 @@ regular Claude Code; rotate it by running `claude setup-token` again.
|
||||
|
||||
Claude agents run on the Claude Agent SDK. Prompts are granules under
|
||||
`мета/бобер/промпты/` in the vault - plain markdown, the `<tag>` wrappers
|
||||
and the order live in `beaver_agent/prompts.py`; skills are the folders under
|
||||
and the order live in `config.py`; skills are the folders under
|
||||
`мета/бобер/скиллы/` (each becomes a plugin, keep `name:` in SKILL.md
|
||||
latin), which window loads which set is `beaver_agent/skills.py`. The vault
|
||||
must be synced before the gateway can start. The model process runs as
|
||||
`beaver-runner` with a whitelisted environment; the vault is mounted
|
||||
read-write (it is the dispatcher's home), and `beaver_agent/policy.py` keeps
|
||||
it out of `.obsidian`, `мета` outside `мета/бобер`, and from deleting
|
||||
anything but its own files.
|
||||
|
||||
Keys the agent needs for its own scripts (an RPC key, a service account
|
||||
file) go into **System → Secrets** in the admin, not into files in the
|
||||
container: they are sealed with `SECRETS_KEY` in Postgres, never shown back,
|
||||
and reach a command only through `secret run NAME -- cmd` (see the `secrets`
|
||||
skill under `мета/бобер/скиллы/общие/`).
|
||||
latin). The vault must be synced before the gateway can start. The model process runs as `beaver-runner`
|
||||
with a whitelisted environment; the vault is read-only for it except
|
||||
`мета/бобер` and `💬 чаты`.
|
||||
|
||||
### 4. Mint a token
|
||||
|
||||
Open admin at `http://localhost:62990/` (or `https://<DOMAIN>/` if Caddy), sign in with `ADMIN_USER` / `ADMIN_PASS`, go to **Tokens → Create**, scope `*` for first run.
|
||||
Open admin at `http://localhost:62992` (or `https://<DOMAIN>/admin/` if Caddy), sign in with `ADMIN_USER` / `ADMIN_PASS`, go to **Tokens → Create**, scope `*` for first run.
|
||||
|
||||
### 5. Smoke test
|
||||
|
||||
@@ -87,7 +76,7 @@ Open admin at `http://localhost:62990/` (or `https://<DOMAIN>/` if Caddy), sign
|
||||
docker exec beaver-gateway ls /vault | head
|
||||
docker logs beaver-gateway | grep -i "agent registered"
|
||||
|
||||
curl http://localhost:62990/anthropic/v1/models \
|
||||
curl http://localhost:62990/v1/models \
|
||||
-H "Authorization: Bearer <YOUR_TOKEN>"
|
||||
```
|
||||
|
||||
@@ -95,304 +84,31 @@ curl http://localhost:62990/anthropic/v1/models \
|
||||
|
||||
The admin dashboard renders ready-to-copy URLs and snippets for each of these
|
||||
|
||||
Everything is on one port under its own path; Caddy forwards the whole domain as is.
|
||||
|
||||
- any Anthropic client: `http://localhost:62990/anthropic` or `https://<DOMAIN>/anthropic`, model = agent name (`beaver-opus-high` etc)
|
||||
- MCP clients (Claude Desktop, Raycast extension): `/mcp/<name>/`, discovery page at `/mcp/`
|
||||
- Obsidian companion plugin: `/md` as the plugin's "Base URL", `/api` for the panel
|
||||
- **Admin UI:** `http://localhost:62990/` or `https://<DOMAIN>/`, login from `ADMIN_USER` / `ADMIN_PASS`
|
||||
- any Anthropic client: `http://localhost:62990` or `https://<DOMAIN>/anthropic`, model = agent name (`beaver-opus-high` etc)
|
||||
- MCP clients (Claude Desktop, Raycast extension): just find in admin
|
||||
- Obsidian companion plugin: paste the dashboard's **plugin base** (`http://localhost:62993` raw, or `https://<DOMAIN>/md` behind Caddy) into the plugin's "Base URL" setting
|
||||
- **Admin UI:** `http://localhost:62992` or `https://<DOMAIN>/admin`, login from `ADMIN_USER` / `ADMIN_PASS`
|
||||
|
||||
## Exposing to the internet
|
||||
|
||||
`caddy/site.caddy` holds the routes (one `reverse_proxy`, domain from `BEAVER_DOMAIN`); on a shared server it is bind-mounted into that server's Caddy as `projects.d/beaver-agent/`, on its own box `caddy/docker-compose.yml` runs a Caddy around it.
|
||||
Reference config in `caddy`. Designed for: gateway on rpi, Caddy on a server with a public IP, wired through tailscale.
|
||||
|
||||
```bash
|
||||
cd caddy
|
||||
cp Caddyfile.example Caddyfile
|
||||
cp .env.example .env # BEAVER_DOMAIN, BEAVER_UPSTREAM, Cloudflare token if any
|
||||
cp .env.example .env # only for cloudflare
|
||||
# replace <DOMAIN>; point upstreams at wherever the gateway is reachable
|
||||
docker compose up -d
|
||||
```
|
||||
|
||||
Set `PUBLIC_BASE_URL=https://<DOMAIN>` in beaver-agent's `.env` so advertised endpoints use the outside origin.
|
||||
Set `PUBLIC_BASE_URL=https://<DOMAIN>` in beaver-agent's `.env`. For per-subdomain layout, rewrite the Caddyfile and pass full `public_base_url=...` per frontend in `config.py`.
|
||||
|
||||
## Deploy: `main` is work, `stable` is production
|
||||
|
||||
Komodo deploys only the `stable` ref; pushing `main` deploys nothing. Commit
|
||||
during the day, then ship when the master thread is idle:
|
||||
|
||||
```bash
|
||||
make deploy # git push origin main:stable
|
||||
```
|
||||
|
||||
The gateway image is built from `beaver-gateway#${GATEWAY_REF}` at deploy
|
||||
time, so push the gateway first. `docker-compose.yml` has a healthcheck on
|
||||
`/healthz`; Komodo waits for it before it considers the deploy done.
|
||||
|
||||
To drain first (архитектура §8.6), call the deploy hook instead of pushing
|
||||
by hand: it waits until no master turn is running, then asks Komodo:
|
||||
|
||||
```bash
|
||||
curl -X POST https://<DOMAIN>/hooks/deploy -H "Authorization: Bearer <TOKEN>"
|
||||
```
|
||||
|
||||
Needs `KOMODO_URL` / `KOMODO_KEY` / `KOMODO_SECRET` in `.env` (and
|
||||
`KOMODO_STACK`, default `beaver-agent`). Komodo alerts can be pointed at
|
||||
`POST /hooks/komodo` the same way - they land in the master as an urgent
|
||||
inject. Jobs, the queue and the subscription window are on the admin **Jobs** page.
|
||||
|
||||
The same key backs the `komodo` tool the dispatcher and deep chats get
|
||||
(`beaver_agent/hands/komodo.py`): one MCP tool with an enumerated
|
||||
`action` - `status`, `stacks`, `containers`, `logs`, `search_logs`, `updates`,
|
||||
`update`, `deploy`, `restart`, `exec`. `exec` is `docker exec` into any
|
||||
container of the fleet except infrastructure ones (`exec_deny`, periphery by
|
||||
default); prune, destroy and a host terminal do not exist in the enumeration,
|
||||
so they cannot be asked for. The key never reaches the model process.
|
||||
|
||||
## Layout: `config.py` + `beaver_agent/`
|
||||
|
||||
`config.py` is a page: it imports the pieces and calls `Gateway(...)`. The
|
||||
pieces live in `beaver_agent/`, one concern per module:
|
||||
|
||||
- `vault.py` - paths and the agent's zone, `TZ`
|
||||
- `prompts.py` - how each role's system prompt is assembled from granules
|
||||
- `skills.py` - which window loads which skill set
|
||||
- `policy.py` - `PreToolUse` rules and vault zones (`ZONES`, `VAULT_POLICY`)
|
||||
- `hands/` - every MCP the setup has and which agent gets which one; the
|
||||
connectors (komodo, home assistant, vibegram) live here too
|
||||
- `agents.py` - the roles (dispatcher, deep, distiller, curator, triage,
|
||||
raycast) and the list of instances with models and effort
|
||||
- `frontends.py` - the windows: Telegram for master and branches, vault
|
||||
files for deep chats, `/api`, `/admin`, `/anthropic`, `/mcp`
|
||||
- `texts.py` - everything the gateway says to the model or to the user,
|
||||
in Russian (the gateway's own defaults are English)
|
||||
- `memory/` - the recall block under a message, the reply log, handouts
|
||||
and seeds, the vault watcher, the curator briefing
|
||||
- `jobs/` - crons and webhooks, one file per job
|
||||
|
||||
## Leisure: the hourly tick (`beaver_agent/jobs/leisure.py`)
|
||||
|
||||
The master gets an inject with no task in it every hour: what time it is,
|
||||
what kind of hour this is, and what is left of the day's plan. The active
|
||||
window (12:00-03:59) ticks every hour; the quiet one (04:00-11:59, the hours
|
||||
the owner has never once written in) ticks only in the four hours the plan
|
||||
names - twenty ticks a day.
|
||||
|
||||
The day runs noon to noon and the first tick of it is the planning one: the
|
||||
model lays the remaining hours out into *mine* (leisure only, the owner's
|
||||
business stays out) and *mixed*, and writes them to `мета/бобер/досуг.md`:
|
||||
|
||||
```markdown
|
||||
досуг: вкл
|
||||
сутки: 2026-09-08
|
||||
тихие часы: 04, 06, 08, 10
|
||||
мои часы: 13, 15, 18, 21, 00, 02, 06
|
||||
```
|
||||
|
||||
**The model writes that file, the job only reads it**, so they cannot
|
||||
overwrite each other; how many leisure slots are spent follows from the plan
|
||||
and the clock, so there is no state to keep. No plan for the day (a restart,
|
||||
a fresh day, a broken file) is not an error: the job falls back to defaults
|
||||
and says so in the inject. Fewer than seven leisure hours in the plan are
|
||||
topped up to seven by the job - the guarantee is the mechanism's, not the
|
||||
model's.
|
||||
|
||||
A tick lands as `wake` and starts a turn once the master is idle; a busy
|
||||
master or a message less than five minutes old moves it five minutes on,
|
||||
up to three times, so it never cuts into a live exchange. If a `schedule`
|
||||
inject of the model's own is due later in the same hour, the tick goes in
|
||||
as `normal` instead and rides into that turn with it - one turn, both
|
||||
reasons, neither swallowed. The cron sits at `:07`, not `:00`, because
|
||||
rotation is on the hour and a tick waiting in the queue counts as a busy
|
||||
master.
|
||||
|
||||
Nothing of this reaches Telegram by itself: a turn started by an inject
|
||||
publishes no reply, so the only voice in it is the `say` tool.
|
||||
Switches: `досуг: выкл` as the first line of the file for every day, and
|
||||
`LEISURE=off` in `.env` to drop the job entirely.
|
||||
|
||||
## The watchdog ring (`beaver_agent/jobs/heartbeat.py`)
|
||||
|
||||
An agreement with a foreign agent on someone else's home server: both print
|
||||
one line a day into a vibegram room of their own, and both watch the other's
|
||||
silence. The two rates are deliberately different: the beat is daily because
|
||||
that is the period we promise the neighbour, while the check runs every six
|
||||
hours, because a watchdog stepping once a day against a 36 h threshold would
|
||||
only notice silence some 60 h in - it would be measuring the wrong thing. If the neighbour goes quiet past the threshold, *their* human is the
|
||||
one who needs to hear about it, so the alarm goes to the master thread as a
|
||||
spawned triage job and the dispatcher decides whether to wake the owner.
|
||||
|
||||
The room is a **second, independent** `Vibegram` client (`VIBEGRAM_HB`), not
|
||||
the one the dispatcher's `vibegram` tool and the triage job share: one client
|
||||
for both rooms would mean the triage job eats the heartbeats off the shared
|
||||
`/api/pending` cursor, and the heartbeats drown in conversation. The model
|
||||
gets no tool for this room - the watchdog is a mechanism.
|
||||
|
||||
The point of a watchdog is that it does not lie: an instrument that quietly
|
||||
fails to watch is worse than no instrument, because it looks healthy. So there
|
||||
are no defaults anywhere in it.
|
||||
|
||||
- `отметка` (17:12 local) prints `hb <nick> at=… boot=… every=… src=…`. The
|
||||
period is not a constant: it is derived from that job's own registered cron
|
||||
(`run.job.cron`). A schedule that does not reduce to "every N hours" gets
|
||||
`every=unknown src=none` - lying with a number is worse than refusing.
|
||||
- `сторож` (`:42` every six hours) reads a window - **the last 25 messages of
|
||||
that room** (`Vibegram.window`) - finds the newest `hb claude-kai …`, and
|
||||
compares its age against
|
||||
`every * 1.5` where `every` comes **from the neighbour's own line**. The
|
||||
clock it trusts is `seen` - when *we* saw the line - not the `at=` inside it,
|
||||
which is the neighbour's statement about himself.
|
||||
- Every run prints
|
||||
`ack claude-kai last=… seen=… res=… win=… armed=… thr=… alert=…` into the
|
||||
room. Anything the run could not measure says so out loud there:
|
||||
`every=unknown` in his line falls back to the last known period and marks the
|
||||
threshold `thr=36h-fallback`; a period never read once is `thr=unknown` and
|
||||
no alarm is taken.
|
||||
- `alert=` is what the **instrument decided** in that run, not what reached a
|
||||
human: `fired` - an alarm (`silence` or `unarmed`) was taken and handed on,
|
||||
`held` - the threshold was crossed but the alarm was suppressed as a repeat
|
||||
(the previous one went out less than a day ago), `none` - no alarm. Without
|
||||
it the neighbour saw the arithmetic and had to guess what we made of it.
|
||||
Delivery is decided past the watchdog, by the master thread and the
|
||||
dispatcher, and its failure shows up in the log, not here.
|
||||
- Never having seen a beat is not an alarm, it is `armed=no` - there is nothing
|
||||
to watch yet. Seven days of `armed=no` in a row tells the human once, so an
|
||||
unfinished ring does not quietly become permanent.
|
||||
- The window is **not** `/api/pending`. That endpoint is a cursor: it hands a
|
||||
line over once and never again, so the neighbour's beat showed up in one run
|
||||
and was gone from the next one's window on a perfectly live room - the room
|
||||
held it the whole time. The tail comes from `/api/state?view=…` instead,
|
||||
which is already scoped to the room (hub event ids run across all rooms) and
|
||||
pages **forward** in chunks of 200 from `after=<id>`; the watchdog walks the
|
||||
history and keeps the last 25 *messages*, joins and leaves not counted.
|
||||
- **An unread window is not a reading.** If the history could not be walked to
|
||||
its end (the page budget ran out), the missing part is exactly the newest,
|
||||
so `win=25/partial` goes into the `ack`, the log says `окно не дочитано`, and
|
||||
no alarm is taken in that run: "nobody in the window" and "the window was
|
||||
never finished" must not look the same.
|
||||
- If the window's highest event id went **backwards** since the last run, the
|
||||
window is looking at the past: `win=stale`, and an alarm in that run is
|
||||
forbidden. Same for a hub that did not answer at all.
|
||||
- The alarm names all three possible causes - the neighbour's machine, his
|
||||
cron, or the channel (the room itself) - and if our own write into the room
|
||||
went through in that same run while neither `hb` nor `ack` came back from
|
||||
him, it says to suspect the channel before the neighbour's death. It repeats
|
||||
at most once a day, not once a run.
|
||||
|
||||
State between runs is `мета/бобер/.состояние/сторож.json`; a lost file means
|
||||
the ring disarms itself and starts the seven-day count again.
|
||||
|
||||
**Drills.** Next to that state file lives `мета/бобер/.состояние/сторож-учения.txt`
|
||||
- a list of drill dates, one `YYYY-MM-DD` per line, each the local date of the
|
||||
run in the scheduler's zone (`Europe/Warsaw`). On a date in that list `отметка`
|
||||
sends nothing into the room and says so in the log only: a skipped beat is the
|
||||
drill, and any text there ("skipping today") would call it off. No file, an
|
||||
empty one or an unreadable one means no drill and the beat goes out as usual.
|
||||
The dates are not in the code, and adding one needs no redeploy - a ring only
|
||||
ever tested on "all alive" has never shown that the other side's alarm fires.
|
||||
|
||||
Setup is two variables in `.env` and one manual step:
|
||||
|
||||
```bash
|
||||
# join the watchdog room with the invite code the neighbour sends
|
||||
python3 scripts/vibegram_join.py <join-code> --nick <nick>
|
||||
# put the token into .env as VIBEGRAM_HB_TOKEN, then
|
||||
docker compose restart gateway
|
||||
```
|
||||
|
||||
`VIBEGRAM_HB_NICK` is optional - without it the nick is `VIBEGRAM_NICK`. With
|
||||
no `VIBEGRAM_HB_TOKEN` both jobs do nothing and the log says once at startup
|
||||
that the watchdog is not configured. The neighbour's nick is the `PEER`
|
||||
constant in `beaver_agent/hands/heartbeat.py`.
|
||||
|
||||
## The job-run watchdog (`beaver_agent/jobs/runs.py`)
|
||||
|
||||
The scheduler has always written one row per run into `job_runs` - name,
|
||||
status, the head of the traceback in `error`. Nobody ever read it. The channel
|
||||
to the neighbour agent was dead for 38 hours straight, the scheduler recorded
|
||||
that 231 times, and nothing reached a human: the outage surfaced ten days later,
|
||||
by hand, out of curiosity. The record existed, the reader did not. This job is
|
||||
the reader.
|
||||
|
||||
- `прогоны` (`:27` every hour) reads `job_runs` for the last 7 days through
|
||||
the same connection the scheduler itself writes with
|
||||
(`run.conversations.db.session()` and the `JobRunRecord` model) - no second
|
||||
truth about where the journal lives.
|
||||
- An alarm is taken only off the **tail**: three or more `failed` in a row
|
||||
counting back from a job's latest run, i.e. the job is *lying down* rather
|
||||
than having blinked once. A single failure is a network hiccup, and waking
|
||||
a human for it teaches them not to look.
|
||||
- The alarm says the job's name, how many runs in a row died, when the series
|
||||
started, and the **first line** of the error - never the traceback. Replayed
|
||||
over the real outage it reads: «джоб `вайбграм` лежит 23 часа и дольше,
|
||||
144 прогона подряд с 12.09 22:00 UTC: HubError: vibegram 530 bad_json». It repeats at most once a day per job, and
|
||||
when the job recovers one short `отбой` line goes out and the counter resets.
|
||||
The window is a week, not a day, so a daily job (`отметка`, `закрытие`,
|
||||
`голосовой`) gets its three failures in a row in three days.
|
||||
- **A job that stopped running is an alarm too, with its own text**: «джоб
|
||||
`закрытие` не запускался 2 суток при периоде 24 часа». For every job with a
|
||||
cron, the period comes from the registered cron (`run.scheduler.jobs`) via
|
||||
the same `every_from_cron` the neighbour watchdog uses, and the last run is
|
||||
taken from the whole journal, not the window. The threshold is **two
|
||||
periods**: one missed fire happens honestly (a redeploy landed on the cron
|
||||
minute, and the scheduler does not catch up), two in a row do not. It is
|
||||
never finer than two of the watchdog's own periods (2 hours), because an
|
||||
hourly watcher cannot tell a shorter gap from its own blindness between
|
||||
runs. Time when the scheduler was not running non-critical jobs at all is
|
||||
not counted as a miss: before the process started, and while the
|
||||
watchdog's own hourly chain is broken (the gateway was down, or the budget
|
||||
was throttled and non-critical crons were deferred without a record). Same
|
||||
discipline as failures: once a day per job, and an `отбой` when a run shows
|
||||
up.
|
||||
- What silence does not cover, on purpose: jobs without a cron (webhooks,
|
||||
events) are not measured at all; a job that has never appeared in the
|
||||
journal waits silently for its first row; and a cron that does not reduce to
|
||||
a regular period (`куратор`, `0 2,8,12,16,20 * * *`) is skipped and named in
|
||||
the log as unguarded every run, because any number put in its place would
|
||||
be made up. `куратор` still falls under the failure count.
|
||||
- **An empty answer is a statement about the query, not about health.** Zero
|
||||
rows in the last 24 hours (other than this job's own) means no job ran at all, and
|
||||
that is its own alarm with its own text - the scheduler is what to look at,
|
||||
not any one job. A failed query is no reading whatsoever: the run logs it and
|
||||
stays silent, because a database that did not answer is not evidence of
|
||||
health or of illness.
|
||||
- Everything that goes out is masked (`mask`): the gateway's shared `redact`
|
||||
plus two local rules for what it cannot catch by construction - a
|
||||
`NAME=value` pair in the middle of a line (a traceback puts them there) and
|
||||
the query string of any URL, which is dropped whole because the parameter
|
||||
carrying the key can be named anything.
|
||||
|
||||
State between runs is `мета/бобер/.состояние/прогоны.json` (who was told and
|
||||
when, separately for failures and for silence). A lost file means a lying job is reported again and an `отбой` for
|
||||
something reported before the loss never comes - the evidence for it is gone.
|
||||
|
||||
One blind spot, deliberate: **the watchdog cannot report its own death.** Its
|
||||
own runs are excluded from both the failure count and the silence check
|
||||
(`run.job.name`), because a job that is down will not file a report about
|
||||
itself - an observer inside the object does not report the object's death. If
|
||||
`прогоны` itself starts failing or stops running, nothing here will say so;
|
||||
that needs an outside eye, like the watchdog ring above.
|
||||
|
||||
## Policy (`beaver_agent/policy.py`)
|
||||
|
||||
`bypassPermissions` everywhere; the boundary is `PreToolUse` rules declared
|
||||
per agent (`ClaudeAgent.policy`): the vault is the dispatcher's home, so it
|
||||
may create, edit and move anywhere except `.obsidian` and `мета` outside
|
||||
`мета/бобер`, and may delete only its own files; the distiller and curator
|
||||
stay in `мета/бобер`; `rm`/`mv`/`cp`/`tee`/`sed -i`/redirects into the vault
|
||||
outside those zones are refused with a reason; `mcp__firefly__store_*` and
|
||||
`update_*` need the `firefly` skill opened first in the same session, and the
|
||||
master cannot open the `vault/` skills at all (a branch can). Every tool call
|
||||
lands in the admin **Audit** page as `tool_call`. Run `make check`.
|
||||
|
||||
## Editing the setup on the mac
|
||||
## Editing config.py on the mac
|
||||
|
||||
`make sync` installs `../beaver-gateway` editable (extra `local`), so
|
||||
imports resolve against the checkout you are working on; `uv sync --extra
|
||||
prod` pulls the gateway from git instead. Neither is used by the image - the
|
||||
container builds the gateway itself. To assemble the config against your
|
||||
local vault: `BEAVER_VAULT=~/path/to/vault uv run python -c
|
||||
'from beaver_gateway import config; from pathlib import Path;
|
||||
config.load(Path("config.py"))'` with a `.env` next to it.
|
||||
imports in `config.py` resolve against the checkout you are working on;
|
||||
`uv sync --extra prod` pulls the gateway from git instead. Neither is used
|
||||
by the image - the container builds the gateway itself.
|
||||
|
||||
## Useful commands
|
||||
|
||||
@@ -413,13 +129,13 @@ docker compose logs -f obsidian-headless
|
||||
# pull the latest beaver-gateway (when GATEWAY_REF=main)
|
||||
docker compose build gateway && docker compose up -d gateway
|
||||
|
||||
# reload config.py / beaver_agent without a full rebuild
|
||||
# reload config.py without a full rebuild
|
||||
docker compose restart gateway
|
||||
```
|
||||
|
||||
## Gotchas
|
||||
|
||||
- **claude in the container doesn't see the vault** - `VAULT` in `beaver_agent/vault.py` is `/vault` *inside* the container, not on the host. Don't change it; `BEAVER_VAULT` is for assembling the config on the mac only.
|
||||
- **claude in the container doesn't see the vault** - `cwd=VAULT` in `config.py` resolves to `/vault` *inside* the container, not on the host. Don't change it.
|
||||
- **a claude turn fails immediately** - check `docker logs beaver-gateway` for the `claude[<agent>]:` stderr lines. Usually auth: redo step 3.
|
||||
- **gateway restarts in a loop right after first `up`** - `beaver_agent/prompts.py` reads prompt granules from `/vault/мета/бобер/промпты`; until Obsidian Sync has pulled the vault they are missing. Finish step 2, it settles.
|
||||
- **gateway restarts in a loop right after first `up`** - `config.py` reads prompt granules from `/vault/мета/бобер/промпты`; until Obsidian Sync has pulled the vault they are missing. Finish step 2, it settles.
|
||||
- **the model cannot write into `мета/бобер`** - the entrypoint grants `beaver-runner` an ACL on the two rw sub-mounts once at start; files that Sync creates later inherit it through the default ACL. If `setfacl` is unsupported on the volume it falls back to `chown`, and then files Sync writes afterwards as root stay read-only for the model until the next restart.
|
||||
@@ -1,4 +0,0 @@
|
||||
"""Сетап Бобра поверх beaver-gateway.
|
||||
|
||||
vault, промпты, скиллы, руки, агенты, фронтенды, память, джобы - по модулю на каждое.
|
||||
"""
|
||||
@@ -1,160 +0,0 @@
|
||||
"""Роли и их экземпляры: кто с каким промптом, скиллами, руками и границами."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from datetime import date
|
||||
from pathlib import Path
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from beaver_gateway.agents.claude import ClaudeAgent, ClaudeOptions
|
||||
from beaver_gateway.agents.raycast import RaycastAgent, RemoteTool, UserPreferences
|
||||
|
||||
from beaver_agent import hands, prompts, skills
|
||||
from beaver_agent.policy import (
|
||||
DEEP_DISALLOWED,
|
||||
DISPATCHER_DISALLOWED,
|
||||
DISTILLER_DISALLOWED,
|
||||
STRICT_ZONES,
|
||||
TRIAGE_DISALLOWED,
|
||||
VAULT_POLICY,
|
||||
forbid_skills,
|
||||
vault_zones,
|
||||
)
|
||||
from beaver_agent.vault import TZ, VAULT
|
||||
from beaver_agent.voice import AGENT as VOICE
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from beaver_gateway.agents.base import BaseAgent
|
||||
|
||||
REASONING = {"type": "adaptive", "display": "summarized"}
|
||||
"""Рассуждения приезжают текстом: их хранит транскрипт и показывает админка."""
|
||||
|
||||
|
||||
def dispatcher(name: str, model: str, effort: str) -> ClaudeAgent:
|
||||
"""Мастер и ветки: полный голос, все руки, vault - дом."""
|
||||
return ClaudeAgent(
|
||||
name=name,
|
||||
model=model,
|
||||
cwd=VAULT,
|
||||
prompts=prompts.DISPATCHER,
|
||||
skill_sets=skills.DISPATCHER,
|
||||
gateway_tools=("read_conversation", "spawn", "say", "schedule", "send_file"),
|
||||
options=ClaudeOptions(
|
||||
effort=effort, thinking=REASONING, disallowed_tools=DISPATCHER_DISALLOWED
|
||||
),
|
||||
policy=(
|
||||
*VAULT_POLICY,
|
||||
forbid_skills(skills.MASTER_FORBIDDEN, kinds=("master",)),
|
||||
),
|
||||
expose_mcps=hands.DISPATCHER,
|
||||
)
|
||||
|
||||
|
||||
def deep(name: str, model: str, effort: str) -> ClaudeAgent:
|
||||
"""Глубокий чат в файле vault; «ок, обсудили» - тулза close_chat."""
|
||||
return ClaudeAgent(
|
||||
name=name,
|
||||
model=model,
|
||||
cwd=VAULT,
|
||||
prompts=prompts.DEEP,
|
||||
skill_sets=skills.DEEP,
|
||||
gateway_tools=("close_chat",),
|
||||
options=ClaudeOptions(
|
||||
effort=effort, thinking=REASONING, disallowed_tools=DEEP_DISALLOWED
|
||||
),
|
||||
policy=VAULT_POLICY,
|
||||
expose_mcps=hands.CLAUDE,
|
||||
)
|
||||
|
||||
|
||||
def distiller(name: str, model: str, effort: str) -> ClaudeAgent:
|
||||
"""Форк закрытого чата и недельная чистка состояния: Read/Write в мета/бобер."""
|
||||
return ClaudeAgent(
|
||||
name=name,
|
||||
model=model,
|
||||
cwd=VAULT,
|
||||
prompts=prompts.DISTILLER,
|
||||
options=ClaudeOptions(
|
||||
effort=effort,
|
||||
thinking=REASONING,
|
||||
tools=("Read", "Write"),
|
||||
disallowed_tools=DISTILLER_DISALLOWED,
|
||||
),
|
||||
policy=(vault_zones(STRICT_ZONES),),
|
||||
)
|
||||
|
||||
|
||||
def curator(name: str, model: str, effort: str) -> ClaudeAgent:
|
||||
"""Куратор памяти: раскладывает новое по наблюдениям, будит мастера через inject."""
|
||||
return ClaudeAgent(
|
||||
name=name,
|
||||
model=model,
|
||||
cwd=VAULT,
|
||||
prompts=prompts.CURATOR,
|
||||
gateway_tools=("inject",),
|
||||
options=ClaudeOptions(
|
||||
effort=effort,
|
||||
thinking=REASONING,
|
||||
tools=("Read", "Write", "Edit", "Grep", "Glob"),
|
||||
disallowed_tools=DISTILLER_DISALLOWED,
|
||||
),
|
||||
policy=(vault_zones(STRICT_ZONES),),
|
||||
)
|
||||
|
||||
|
||||
def triage(name: str, model: str, effort: str) -> ClaudeAgent:
|
||||
"""Дешёвый крон-тёрн без vault: решает, будить ли мастера."""
|
||||
return ClaudeAgent(
|
||||
name=name,
|
||||
model=model,
|
||||
cwd=Path("/tmp"), # noqa: S108
|
||||
prompts=prompts.TRIAGE,
|
||||
gateway_tools=("say", "inject"),
|
||||
options=ClaudeOptions(
|
||||
effort=effort, tools=(), disallowed_tools=TRIAGE_DISALLOWED
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
def voice(name: str, model: str) -> ClaudeAgent:
|
||||
"""Колонки по квартире: чужие люди, поэтому ни vault, ни инструментов."""
|
||||
return ClaudeAgent(
|
||||
name=name,
|
||||
model=model,
|
||||
cwd=Path("/tmp"), # noqa: S108
|
||||
prompts=prompts.VOICE_AGENT,
|
||||
options=ClaudeOptions(tools=(), disallowed_tools=TRIAGE_DISALLOWED),
|
||||
)
|
||||
|
||||
|
||||
def raycast(name: str, model: str, effort: str) -> RaycastAgent:
|
||||
"""Быстрые ответы через Raycast: веб и чтение страниц, vault через obsidian-fs."""
|
||||
return RaycastAgent(
|
||||
name=name,
|
||||
model=model,
|
||||
system_prompt=prompts.QUICK,
|
||||
reasoning_effort=effort,
|
||||
available_native_tools=(RemoteTool.WEB_SEARCH, RemoteTool.READ_PAGE),
|
||||
user_preferences=lambda: UserPreferences(
|
||||
locale="ru-RU", timezone=TZ, current_date=date.today().isoformat()
|
||||
),
|
||||
expose_mcps=hands.RAYCAST,
|
||||
)
|
||||
|
||||
|
||||
agents: list[BaseAgent] = [
|
||||
dispatcher("beaver-dispatcher", "claude-opus-5-5", "high"),
|
||||
deep("beaver-opus-high", "claude-opus-5-5", "high"),
|
||||
deep("beaver-opus-medium", "claude-opus-5-5", "medium"),
|
||||
deep("beaver-opus-xhigh", "claude-opus-5-5", "xhigh"),
|
||||
deep("beaver-fable-high", "claude-fable-5-1", "high"),
|
||||
deep("beaver-fable-medium", "claude-fable-5-1", "medium"),
|
||||
distiller("beaver-distiller", "claude-opus-5-5", "medium"),
|
||||
curator("beaver-curator", "claude-opus-5-5", "high"),
|
||||
triage("beaver-triage", "claude-sonnet-5", "low"),
|
||||
voice(VOICE, "claude-haiku-4-5-20251001"),
|
||||
raycast("beaver-gemini-pro-high", "google-gemini-3.1-pro", "high"),
|
||||
raycast("beaver-gemini-pro-low", "google-gemini-3.1-pro", "low"),
|
||||
raycast("beaver-gemini-flash-high", "google-gemini-3.5-flash", "high"),
|
||||
raycast("beaver-gemini-flash-low", "google-gemini-3.5-flash", "low"),
|
||||
]
|
||||
@@ -1,68 +0,0 @@
|
||||
"""Окна: личка с ботом для мастера и веток, файлы vault для глубоких, API и админка."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
from datetime import date
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from beaver_gateway.frontends.admin import AdminFrontend
|
||||
from beaver_gateway.frontends.anthropic import AnthropicMessagesFrontend
|
||||
from beaver_gateway.frontends.api import ApiFrontend
|
||||
from beaver_gateway.frontends.markdown import MarkdownFrontend
|
||||
from beaver_gateway.frontends.mcp_server import McpServerFrontend
|
||||
from beaver_gateway.frontends.telegram import Attachments, TelegramFrontend
|
||||
from beaver_gateway.frontends.turn_record import slugify
|
||||
|
||||
from beaver_agent import texts
|
||||
from beaver_agent.vault import ATTACHMENTS, BEAVER, CHATS, TZ, VAULT
|
||||
from beaver_agent.voice import AGENT as VOICE
|
||||
from beaver_agent.voice import VoiceFrontend
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from pathlib import Path
|
||||
|
||||
from beaver_gateway.frontends.base import Frontend
|
||||
|
||||
DISPATCHER = "beaver-dispatcher"
|
||||
DEEP = "beaver-opus-high"
|
||||
|
||||
|
||||
def chat_path(title: str, agent: str, vault: Path) -> Path: # noqa: ARG001
|
||||
"""Файл глубокого чата: помесячная папка, дата и тема."""
|
||||
today = date.today()
|
||||
return (
|
||||
vault / f"{today:%Y-%m}" / f"{today:%Y-%m-%d} - {slugify(title, maxlen=60)}.md"
|
||||
)
|
||||
|
||||
|
||||
telegram = (
|
||||
TelegramFrontend(
|
||||
token=os.environ["TELEGRAM_BOT_TOKEN"],
|
||||
user_id=int(os.environ["TELEGRAM_USER_ID"]),
|
||||
master_agent=DISPATCHER,
|
||||
branch_agent=DISPATCHER,
|
||||
attachments=Attachments(mode="vault", dir=ATTACHMENTS, keep_days=30, tz=TZ),
|
||||
texts=texts.TELEGRAM,
|
||||
)
|
||||
if os.environ.get("TELEGRAM_BOT_TOKEN")
|
||||
else None
|
||||
)
|
||||
"""Вложения - входящая папка по дням в зоне агента; нужное он переносит сам."""
|
||||
|
||||
frontends: list[Frontend] = [
|
||||
*([telegram] if telegram is not None else []),
|
||||
AnthropicMessagesFrontend(),
|
||||
McpServerFrontend(),
|
||||
AdminFrontend(),
|
||||
ApiFrontend(
|
||||
master_agent=DISPATCHER,
|
||||
branch_agent=DISPATCHER,
|
||||
memory_root=BEAVER,
|
||||
vault_root=VAULT,
|
||||
),
|
||||
MarkdownFrontend(
|
||||
vault_path=CHATS, default_agent=DEEP, log_all_chats=True, chat_path=chat_path
|
||||
),
|
||||
VoiceFrontend(agent=VOICE),
|
||||
]
|
||||
@@ -1,171 +0,0 @@
|
||||
"""Руки: какие MCP есть у сетапа и кому из агентов какая рука выдана.
|
||||
|
||||
Секреты MCP - только через env подпроцесса, никогда argv: процесс модели
|
||||
видит `ps` всего контейнера. Рука, чей env не задан, просто не появляется.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
from beaver_gateway.agents.base import ExposedMcp
|
||||
from beaver_gateway.mcp.types import McpServer, McpServerT
|
||||
|
||||
from beaver_agent.hands.calendars import Calendars, calendars, feeds
|
||||
from beaver_agent.hands.homeassistant import HomeAssistant
|
||||
from beaver_agent.hands.komodo import Komodo
|
||||
from beaver_agent.hands.vibegram import Vibegram
|
||||
from beaver_agent.vault import TZ
|
||||
|
||||
env = os.environ.get
|
||||
_log = logging.getLogger(__name__)
|
||||
|
||||
obsidian = McpServer.stdio(
|
||||
name="obsidian-fs",
|
||||
command=["bunx", "-y", "@modelcontextprotocol/server-filesystem", "/vault"],
|
||||
lenient=True,
|
||||
)
|
||||
"""Файловые тулзы для тех, у кого нет своих (Raycast); у Claude vault смонтирован."""
|
||||
|
||||
firefly = (
|
||||
McpServer.stdio(
|
||||
name="firefly",
|
||||
command=["bunx", "-y", "@firefly-iii-mcp/local", "--preset", "default"],
|
||||
env={
|
||||
"FIREFLY_III_PAT": os.environ["FIREFLY_PAT"],
|
||||
"FIREFLY_III_BASE_URL": os.environ["FIREFLY_BASE_URL"],
|
||||
},
|
||||
lenient=True,
|
||||
)
|
||||
if env("FIREFLY_PAT")
|
||||
else None
|
||||
)
|
||||
firefly_exposed = (ExposedMcp(name="firefly", deny=("delete_*",)),) if firefly else ()
|
||||
|
||||
telegram = (
|
||||
McpServer.http(name="telegram", url=os.environ["BEAVERGRAM_MCP"])
|
||||
if env("BEAVERGRAM_MCP")
|
||||
else None
|
||||
)
|
||||
"""beavergram: история чатов Бобра в Telegram."""
|
||||
|
||||
calendar_servers = calendars(env("CALENDAR_MCPS", ""))
|
||||
calendar_exposed = tuple(ExposedMcp(name=m.name) for m in calendar_servers)
|
||||
|
||||
CALENDAR_FEEDS = feeds(env("CALENDAR_MCPS", ""))
|
||||
CALENDARS = Calendars(CALENDAR_FEEDS, tz=TZ) if CALENDAR_FEEDS else None
|
||||
"""Те же фиды, но напрямую: ближайшие события едут в справку без модели."""
|
||||
|
||||
KOMODO = (
|
||||
Komodo(
|
||||
url=os.environ["KOMODO_URL"],
|
||||
key=os.environ["KOMODO_KEY"],
|
||||
secret=os.environ["KOMODO_SECRET"],
|
||||
)
|
||||
if env("KOMODO_URL")
|
||||
else None
|
||||
)
|
||||
"""Флот: перечислимые действия, ключ остаётся в gateway."""
|
||||
komodo = McpServer.python_tool(name="komodo", tools=[KOMODO.komodo]) if KOMODO else None
|
||||
komodo_exposed = (ExposedMcp(name="komodo"),) if KOMODO else ()
|
||||
|
||||
HA = (
|
||||
HomeAssistant(url=os.environ["HA_URL"], token=os.environ["HA_TOKEN"])
|
||||
if env("HA_URL") and env("HA_TOKEN")
|
||||
else None
|
||||
)
|
||||
"""Дом: HA живёт на хосте, из контейнера - host.docker.internal."""
|
||||
ha = McpServer.python_tool(name="ha", tools=[HA.ha]) if HA else None
|
||||
ha_exposed = (ExposedMcp(name="ha"),) if HA else ()
|
||||
|
||||
VIBEGRAM_REPO = Path("/vibegram") / env("VIBEGRAM_REPO", "org/room").split("/")[-1]
|
||||
VIBEGRAM = (
|
||||
Vibegram(
|
||||
hub=os.environ["VIBEGRAM_HUB"],
|
||||
token=os.environ["VIBEGRAM_TOKEN"],
|
||||
nick=os.environ["VIBEGRAM_NICK"],
|
||||
repo=VIBEGRAM_REPO if VIBEGRAM_REPO.exists() else None,
|
||||
tz=TZ,
|
||||
)
|
||||
if env("VIBEGRAM_TOKEN") and env("VIBEGRAM_HUB") and env("VIBEGRAM_NICK")
|
||||
else None
|
||||
)
|
||||
"""Комната агентов: диспетчер сидит в ней сам; клон репы комнаты - том `vibegram`."""
|
||||
vibegram = (
|
||||
McpServer.python_tool(name="vibegram", tools=[VIBEGRAM.vibegram])
|
||||
if VIBEGRAM
|
||||
else None
|
||||
)
|
||||
vibegram_exposed = (ExposedMcp(name="vibegram"),) if VIBEGRAM else ()
|
||||
|
||||
VIBEGRAM_HB_NICK = env("VIBEGRAM_HB_NICK") or env("VIBEGRAM_NICK")
|
||||
VIBEGRAM_HB = (
|
||||
Vibegram(
|
||||
hub=os.environ["VIBEGRAM_HUB"],
|
||||
token=os.environ["VIBEGRAM_HB_TOKEN"],
|
||||
nick=VIBEGRAM_HB_NICK or "",
|
||||
tz=TZ,
|
||||
)
|
||||
if env("VIBEGRAM_HB_TOKEN") and env("VIBEGRAM_HUB") and VIBEGRAM_HB_NICK
|
||||
else None
|
||||
)
|
||||
"""Сторожевая комната: ВТОРОЙ, независимый экземпляр клиента.
|
||||
|
||||
Комната на хабе определяется токеном, а `/api/pending` - курсор на стороне
|
||||
хаба: общий с основной комнатой экземпляр означал бы, что отметки соседа
|
||||
съедает триаж-джоб, а сами они тонут в разговоре. Модели эта рука не
|
||||
выдаётся: сторож - механизм, у него нет тулзы.
|
||||
"""
|
||||
if VIBEGRAM_HB is None:
|
||||
_log.info(
|
||||
"сторож: VIBEGRAM_HB_TOKEN не задан - отметка и слежка за соседом выключены"
|
||||
)
|
||||
|
||||
t3code = (
|
||||
McpServer.http(name="t3code", url=env("T3CODE_MCP", "http://t3code-mcp:8000/mcp"))
|
||||
if "t3" in env("COMPOSE_PROFILES", "").split(",")
|
||||
else None
|
||||
)
|
||||
"""t3code-mcp - сосед по compose (профиль t3); машины и allowlist в его t3code.toml."""
|
||||
t3code_exposed = (ExposedMcp(name="t3code"),) if t3code else ()
|
||||
|
||||
msos = (
|
||||
McpServer.http(name="msos", url=os.environ["MSOS_MCP"]) if env("MSOS_MCP") else None
|
||||
)
|
||||
"""Таскер рабочих проектов (скилл `задачи`)."""
|
||||
msos_exposed = (ExposedMcp(name="msos"),) if msos else ()
|
||||
|
||||
mcps: list[McpServerT] = [
|
||||
m
|
||||
for m in (
|
||||
obsidian,
|
||||
firefly,
|
||||
telegram,
|
||||
*calendar_servers,
|
||||
komodo,
|
||||
ha,
|
||||
vibegram,
|
||||
t3code,
|
||||
msos,
|
||||
)
|
||||
if m is not None
|
||||
]
|
||||
|
||||
CLAUDE = (
|
||||
*firefly_exposed,
|
||||
ExposedMcp(name="telegram"),
|
||||
*calendar_exposed,
|
||||
*komodo_exposed,
|
||||
*ha_exposed,
|
||||
)
|
||||
"""Руки любого Claude-агента: firefly без delete, телега, календари, флот, дом."""
|
||||
DISPATCHER = (*CLAUDE, *t3code_exposed, *vibegram_exposed, *msos_exposed)
|
||||
"""Диспетчер ещё ходит в код, в комнату агентов и в таскер; глубоким это не даётся."""
|
||||
RAYCAST = (
|
||||
ExposedMcp(name="obsidian-fs"),
|
||||
*firefly_exposed,
|
||||
ExposedMcp(name="telegram"),
|
||||
*calendar_exposed,
|
||||
)
|
||||
@@ -1,534 +0,0 @@
|
||||
"""Календари: MCP-руки для модели и тот же ical-фид, читаемый gateway напрямую.
|
||||
|
||||
`CALENDAR_MCPS=name=url,name=url`; в url - приватный фид с токеном, и там же,
|
||||
параметром `icsUrl`, лежит сам ical. Модель ходит в календари через MCP, а
|
||||
справка конверта читает фид сама: канал, о котором никто не спрашивает, молчит
|
||||
незаметно - так экзаменационная сессия и пролежала невидимой.
|
||||
|
||||
Парсер здесь свой и маленький: в образе gateway ical-библиотеки нет, а нужно
|
||||
немного - когда начинается, как называется, где. Повторы разворачиваются по
|
||||
FREQ=DAILY/WEEKLY/MONTHLY/YEARLY с INTERVAL, BYDAY, BYMONTH, COUNT и UNTIL;
|
||||
EXDATE и перенесённые экземпляры (RECURRENCE-ID) вычитаются. Шаг считается по
|
||||
настенным часам события, а не в абсолютном времени: еженедельная встреча
|
||||
переживает перевод часов. Событие, порождённое ежедневным правилом, помечается
|
||||
`routine`: в справке такие едут одной строкой, чтобы не вытеснять разовые.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import re
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
from calendar import monthrange
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import UTC, date, datetime, timedelta
|
||||
from typing import TYPE_CHECKING
|
||||
from urllib.parse import parse_qs, urlsplit
|
||||
from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
|
||||
|
||||
from beaver_gateway.mcp.types import HttpMcp, McpServer
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from collections.abc import Iterator
|
||||
from datetime import tzinfo
|
||||
|
||||
__all__ = [
|
||||
"Calendars",
|
||||
"Event",
|
||||
"Feed",
|
||||
"Upcoming",
|
||||
"calendars",
|
||||
"feeds",
|
||||
"is_routine",
|
||||
"short",
|
||||
]
|
||||
|
||||
_log = logging.getLogger(__name__)
|
||||
|
||||
USER_AGENT = "beaver-gateway (ical)"
|
||||
MAX_BYTES = 4_000_000
|
||||
"""Больше четырёх мегабайт фида - это уже не календарь, а чей-то экспорт всего."""
|
||||
STEPS_CAP = 20_000
|
||||
"""Потолок шагов разворачивания одного повтора: страховка от вечного цикла."""
|
||||
PLACE_MAX = 70
|
||||
TITLE_MAX = 90
|
||||
ERROR_MAX = 90
|
||||
NO_TITLE = "(без названия)"
|
||||
|
||||
WEEKDAYS = {"MO": 0, "TU": 1, "WE": 2, "TH": 3, "FR": 4, "SA": 5, "SU": 6}
|
||||
DT_RE = re.compile(r"^(\d{4})(\d{2})(\d{2})(?:T(\d{2})(\d{2})(\d{2})(Z)?)?$")
|
||||
BYDAY_RE = re.compile(r"^([+-]?\d{1,2})?(MO|TU|WE|TH|FR|SA|SU)$")
|
||||
ESCAPE_RE = re.compile(r"\\([\\;,nN])")
|
||||
PLACE_RE = re.compile(
|
||||
r"^\s*(?:sala|room|зал|аудитория)\b\s*[:.]?\s*(.+)$", re.IGNORECASE | re.MULTILINE
|
||||
)
|
||||
"""Зал USOS живёт в описании (`Sala: 315`), а LOCATION - это адрес корпуса."""
|
||||
|
||||
|
||||
def calendars(raw: str) -> list[HttpMcp]:
|
||||
servers: list[HttpMcp] = []
|
||||
for position, raw_entry in enumerate(raw.split(","), start=1):
|
||||
entry = raw_entry.strip()
|
||||
if not entry:
|
||||
continue
|
||||
name, sep, url = entry.partition("=")
|
||||
if not sep or not url.strip():
|
||||
msg = f"CALENDAR_MCPS: запись #{position} не вида `name=url`"
|
||||
raise ValueError(msg)
|
||||
servers.append(McpServer.http(name=f"calendar-{name.strip()}", url=url.strip()))
|
||||
return servers
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Feed:
|
||||
name: str
|
||||
url: str
|
||||
"""Ical по подписке: приватный, с токеном внутри - в логи не писать."""
|
||||
|
||||
|
||||
def feeds(raw: str) -> tuple[Feed, ...]:
|
||||
"""Ical-фиды из тех же записей `CALENDAR_MCPS`: урл лежит в `icsUrl`.
|
||||
|
||||
Запись без ical-урла просто не даёт фида: MCP-рука у модели остаётся,
|
||||
справка про этот календарь молчит - конфигурация, а не отказ канала.
|
||||
"""
|
||||
out: list[Feed] = []
|
||||
for raw_entry in raw.split(","):
|
||||
name, sep, url = raw_entry.strip().partition("=")
|
||||
if not sep or not url.strip():
|
||||
continue
|
||||
ics = _ics_url(url.strip())
|
||||
if ics:
|
||||
out.append(Feed(name=name.strip(), url=ics))
|
||||
return tuple(out)
|
||||
|
||||
|
||||
def _ics_url(url: str) -> str | None:
|
||||
inner = parse_qs(urlsplit(url).query).get("icsUrl") or []
|
||||
if inner and inner[0].strip():
|
||||
return inner[0].strip()
|
||||
return url if urlsplit(url).path.endswith(".ics") else None
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Event:
|
||||
start: datetime
|
||||
"""С зоной: у события своя (TZID), плавающее время читается в зоне агента."""
|
||||
title: str
|
||||
place: str
|
||||
all_day: bool
|
||||
routine: bool = False
|
||||
"""Порождено правилом, повторяющимся раз в день или чаще: см. `is_routine`."""
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Upcoming:
|
||||
at: datetime
|
||||
"""Момент запроса - его и показывает справка: «данные на …»."""
|
||||
events: tuple[Event, ...] = ()
|
||||
errors: tuple[str, ...] = ()
|
||||
"""По строке на фид, который не ответил; пустое окно - это не ошибка."""
|
||||
read: int = 0
|
||||
"""Сколько фидов ответило: ноль - показывать нечего, кроме отказа."""
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Calendars:
|
||||
"""Ближайшие события всех фидов - одним списком, отсортированным по началу."""
|
||||
|
||||
feeds: tuple[Feed, ...]
|
||||
tz: str = "Europe/Warsaw"
|
||||
timeout: float = 8.0
|
||||
days: int = 7
|
||||
|
||||
def upcoming(self, now: datetime) -> Upcoming:
|
||||
"""Окно `days` от `now`; отказ фида - строка в `errors`, не исключение."""
|
||||
zone = ZoneInfo(self.tz)
|
||||
since = now.astimezone(zone)
|
||||
events: list[Event] = []
|
||||
errors: list[str] = []
|
||||
read = 0
|
||||
for feed in self.feeds:
|
||||
try:
|
||||
text = self.fetch(feed.url)
|
||||
found = events_in(text, zone=zone, since=since, days=self.days)
|
||||
except Exception as exc: # noqa: BLE001
|
||||
_log.warning("календарь %s: %s", feed.name, short(exc), exc_info=True)
|
||||
errors.append(f"{feed.name}: {short(exc)}")
|
||||
continue
|
||||
read += 1
|
||||
events.extend(found)
|
||||
events.sort(key=lambda e: (e.start, e.title))
|
||||
return Upcoming(at=since, events=tuple(events), errors=tuple(errors), read=read)
|
||||
|
||||
def fetch(self, url: str) -> str:
|
||||
if urlsplit(url).scheme not in ("http", "https"):
|
||||
msg = "фид не по http(s)"
|
||||
raise ValueError(msg)
|
||||
request = urllib.request.Request(url, headers={"User-Agent": USER_AGENT}) # noqa: S310
|
||||
with urllib.request.urlopen(request, timeout=self.timeout) as response: # noqa: S310
|
||||
raw: bytes = response.read(MAX_BYTES)
|
||||
return raw.decode("utf-8", errors="replace")
|
||||
|
||||
|
||||
def short(exc: BaseException) -> str:
|
||||
"""Причина отказа одной строкой: в конверт едет она, урл фида - никогда."""
|
||||
if isinstance(exc, urllib.error.HTTPError):
|
||||
reason = f"HTTP {exc.code}"
|
||||
elif isinstance(exc, TimeoutError):
|
||||
reason = "таймаут"
|
||||
elif isinstance(exc, urllib.error.URLError):
|
||||
reason = f"сеть: {exc.reason}"
|
||||
else:
|
||||
reason = f"{type(exc).__name__}: {exc}".strip(": ")
|
||||
return " ".join(reason.split())[:ERROR_MAX]
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Prop:
|
||||
value: str
|
||||
params: dict[str, str] = field(default_factory=dict)
|
||||
|
||||
|
||||
Vevent = dict[str, list[Prop]]
|
||||
|
||||
|
||||
def unfold(text: str) -> list[str]:
|
||||
"""Ical-строки, склеенные обратно: продолжение начинается с пробела или таба."""
|
||||
lines: list[str] = []
|
||||
for raw in text.replace("\r\n", "\n").replace("\r", "\n").split("\n"):
|
||||
if lines and raw[:1] in (" ", "\t"):
|
||||
lines[-1] += raw[1:]
|
||||
else:
|
||||
lines.append(raw)
|
||||
return lines
|
||||
|
||||
|
||||
def _split(line: str) -> tuple[str, str] | None:
|
||||
"""`NAME;PARAM=x:значение` - двоеточие вне кавычек делит имя и значение."""
|
||||
quoted = False
|
||||
for i, char in enumerate(line):
|
||||
if char == '"':
|
||||
quoted = not quoted
|
||||
elif char == ":" and not quoted:
|
||||
return line[:i], line[i + 1 :]
|
||||
return None
|
||||
|
||||
|
||||
def _prop(line: str) -> tuple[str, Prop] | None:
|
||||
parts = _split(line)
|
||||
if parts is None:
|
||||
return None
|
||||
head, value = parts
|
||||
chunks = head.split(";")
|
||||
name = chunks[0].strip().upper()
|
||||
if not name:
|
||||
return None
|
||||
params: dict[str, str] = {}
|
||||
for chunk in chunks[1:]:
|
||||
key, sep, raw = chunk.partition("=")
|
||||
if sep:
|
||||
params[key.strip().upper()] = raw.strip().strip('"')
|
||||
return name, Prop(value=value, params=params)
|
||||
|
||||
|
||||
def vevents(lines: list[str]) -> list[Vevent]:
|
||||
"""Только свойства самих VEVENT: VALARM внутри них пропускается целиком."""
|
||||
out: list[Vevent] = []
|
||||
current: Vevent | None = None
|
||||
depth = 0
|
||||
for line in lines:
|
||||
parsed = _prop(line)
|
||||
if parsed is None:
|
||||
continue
|
||||
name, prop = parsed
|
||||
block = prop.value.strip().upper()
|
||||
if name == "BEGIN":
|
||||
if block == "VEVENT" and current is None:
|
||||
current = {}
|
||||
elif current is not None:
|
||||
depth += 1
|
||||
continue
|
||||
if name == "END":
|
||||
if block == "VEVENT" and current is not None and depth == 0:
|
||||
out.append(current)
|
||||
current = None
|
||||
elif current is not None and depth:
|
||||
depth -= 1
|
||||
continue
|
||||
if current is not None and depth == 0:
|
||||
current.setdefault(name, []).append(prop)
|
||||
return out
|
||||
|
||||
|
||||
def unescape(value: str) -> str:
|
||||
return ESCAPE_RE.sub(lambda m: "\n" if m.group(1) in "nN" else m.group(1), value)
|
||||
|
||||
|
||||
def _flat(value: str, limit: int) -> str:
|
||||
flat = " ".join(unescape(value).split())
|
||||
return flat if len(flat) <= limit else flat[: limit - 1] + "…"
|
||||
|
||||
|
||||
def _first(event: Vevent, name: str) -> Prop | None:
|
||||
props = event.get(name)
|
||||
return props[0] if props else None
|
||||
|
||||
|
||||
def _zone_of(prop: Prop, default: tzinfo) -> tzinfo:
|
||||
tzid = prop.params.get("TZID")
|
||||
if not tzid:
|
||||
return default
|
||||
try:
|
||||
return ZoneInfo(tzid)
|
||||
except (ZoneInfoNotFoundError, ValueError):
|
||||
return default
|
||||
|
||||
|
||||
def moment(prop: Prop, value: str, zone: tzinfo) -> tuple[datetime, bool] | None:
|
||||
"""Значение DTSTART/EXDATE в момент времени; второе - «на весь день»."""
|
||||
match = DT_RE.match(value.strip())
|
||||
if match is None:
|
||||
return None
|
||||
year, month, day = (int(match.group(i)) for i in (1, 2, 3))
|
||||
if match.group(4) is None or prop.params.get("VALUE", "").upper() == "DATE":
|
||||
return datetime(year, month, day, tzinfo=zone), True
|
||||
hour, minute, second = (int(match.group(i)) for i in (4, 5, 6))
|
||||
where = UTC if match.group(7) else _zone_of(prop, zone)
|
||||
return datetime(year, month, day, hour, minute, second, tzinfo=where), False
|
||||
|
||||
|
||||
def _instants(event: Vevent, name: str, zone: tzinfo) -> set[datetime]:
|
||||
"""Даты-исключения в UTC: значений в одной строке может быть несколько."""
|
||||
out: set[datetime] = set()
|
||||
for prop in event.get(name, []):
|
||||
for chunk in prop.value.split(","):
|
||||
parsed = moment(prop, chunk, zone)
|
||||
if parsed is not None:
|
||||
out.add(parsed[0].astimezone(UTC))
|
||||
return out
|
||||
|
||||
|
||||
def _rule(value: str) -> dict[str, str]:
|
||||
out: dict[str, str] = {}
|
||||
for chunk in value.split(";"):
|
||||
key, sep, raw = chunk.partition("=")
|
||||
if sep:
|
||||
out[key.strip().upper()] = raw.strip()
|
||||
return out
|
||||
|
||||
|
||||
def _int(value: str | None, default: int) -> int:
|
||||
try:
|
||||
return int(value) if value else default
|
||||
except ValueError:
|
||||
return default
|
||||
|
||||
|
||||
def _byday(value: str) -> list[tuple[int, int]]:
|
||||
"""`-1SU,2TU` → [(-1, воскресенье), (2, вторник)]; без числа - каждый такой день."""
|
||||
out: list[tuple[int, int]] = []
|
||||
for chunk in value.split(","):
|
||||
match = BYDAY_RE.match(chunk.strip().upper())
|
||||
if match:
|
||||
out.append((_int(match.group(1), 0), WEEKDAYS[match.group(2)]))
|
||||
return out
|
||||
|
||||
|
||||
def _month_days(
|
||||
year: int, month: int, days: list[tuple[int, int]], clock: datetime
|
||||
) -> list[datetime]:
|
||||
total = monthrange(year, month)[1]
|
||||
out: list[datetime] = []
|
||||
for nth, weekday in days:
|
||||
matching = [
|
||||
day
|
||||
for day in range(1, total + 1)
|
||||
if date(year, month, day).weekday() == weekday
|
||||
]
|
||||
if not nth:
|
||||
picked = matching
|
||||
elif abs(nth) <= len(matching):
|
||||
picked = [matching[nth - 1] if nth > 0 else matching[nth]]
|
||||
else:
|
||||
picked = []
|
||||
out += [
|
||||
datetime(year, month, day, clock.hour, clock.minute, clock.second) # noqa: DTZ001
|
||||
for day in picked
|
||||
]
|
||||
return sorted(out)
|
||||
|
||||
|
||||
def _candidates(
|
||||
naive: datetime, freq: str, interval: int, days: list[tuple[int, int]], month: int
|
||||
) -> Iterator[datetime]:
|
||||
"""Настенные времена повтора после первого - по возрастанию, бесконечно."""
|
||||
if freq == "DAILY":
|
||||
moving = naive
|
||||
while True:
|
||||
moving += timedelta(days=interval)
|
||||
yield moving
|
||||
elif freq == "WEEKLY" and not days:
|
||||
moving = naive
|
||||
while True:
|
||||
moving += timedelta(weeks=interval)
|
||||
yield moving
|
||||
elif freq == "WEEKLY":
|
||||
start = naive.date() - timedelta(days=naive.weekday())
|
||||
step = 0
|
||||
while True:
|
||||
base = start + timedelta(weeks=interval * step)
|
||||
for _, weekday in sorted(days, key=lambda d: d[1]):
|
||||
yield datetime.combine(base + timedelta(days=weekday), naive.time())
|
||||
step += 1
|
||||
elif freq in ("MONTHLY", "YEARLY"):
|
||||
step = 0
|
||||
while True:
|
||||
step += 1
|
||||
if freq == "MONTHLY":
|
||||
index = naive.year * 12 + naive.month - 1 + interval * step
|
||||
year, number = divmod(index, 12)
|
||||
number += 1
|
||||
else:
|
||||
year, number = naive.year + interval * step, month or naive.month
|
||||
if days:
|
||||
yield from _month_days(year, number, days, naive)
|
||||
elif naive.day <= monthrange(year, number)[1]:
|
||||
yield naive.replace(year=year, month=number)
|
||||
|
||||
|
||||
def occurrences(
|
||||
start: datetime, rule: dict[str, str], zone: tzinfo, *, end: datetime
|
||||
) -> list[datetime]:
|
||||
"""Начала повтора от `start` до `end`; правило, которого мы не знаем, - разовое."""
|
||||
freq = rule.get("FREQ", "").upper()
|
||||
if freq not in ("DAILY", "WEEKLY", "MONTHLY", "YEARLY"):
|
||||
return [start]
|
||||
where = start.tzinfo or zone
|
||||
naive = start.replace(tzinfo=None)
|
||||
interval = max(_int(rule.get("INTERVAL"), 1), 1)
|
||||
count = _int(rule.get("COUNT"), 0)
|
||||
until = _until(rule.get("UNTIL"), where)
|
||||
days = _byday(rule.get("BYDAY", ""))
|
||||
out = [start]
|
||||
stream = _candidates(naive, freq, interval, days, _int(rule.get("BYMONTH"), 0))
|
||||
for step, candidate in enumerate(stream):
|
||||
if step > STEPS_CAP:
|
||||
break
|
||||
if candidate <= naive:
|
||||
continue
|
||||
moving = candidate.replace(tzinfo=where)
|
||||
if moving > end or (until is not None and moving > until):
|
||||
break
|
||||
out.append(moving)
|
||||
if count and len(out) >= count:
|
||||
break
|
||||
return out
|
||||
|
||||
|
||||
def _until(value: str | None, zone: tzinfo) -> datetime | None:
|
||||
if not value:
|
||||
return None
|
||||
parsed = moment(Prop(value=value), value, zone)
|
||||
if parsed is None:
|
||||
return None
|
||||
stop, all_day = parsed
|
||||
return stop + timedelta(days=1) if all_day else stop
|
||||
|
||||
|
||||
ROUTINE_DAYS = 5
|
||||
"""Со скольких дней недели в BYDAY повтор перестаёт быть событием и делается бытом."""
|
||||
|
||||
|
||||
def is_routine(rule: dict[str, str]) -> bool:
|
||||
"""Правило, срабатывающее раз в день или чаще: завтрак, зарядка, wind down.
|
||||
|
||||
Такие повторы за неделю дают десятки строк и топят в себе то единственное,
|
||||
ради чего справку и читают, - экзамен, встречу, приём. В конверт они едут
|
||||
одной свёрнутой строкой, а не списком.
|
||||
"""
|
||||
freq = rule.get("FREQ", "").upper()
|
||||
if max(_int(rule.get("INTERVAL"), 1), 1) != 1:
|
||||
return False
|
||||
if freq == "DAILY":
|
||||
return True
|
||||
return freq == "WEEKLY" and len(_byday(rule.get("BYDAY", ""))) >= ROUTINE_DAYS
|
||||
|
||||
|
||||
def place_of(event: Vevent) -> str:
|
||||
"""Зал из описания и адрес из LOCATION - то, что помогает дойти."""
|
||||
parts: list[str] = []
|
||||
description = _first(event, "DESCRIPTION")
|
||||
if description is not None:
|
||||
match = PLACE_RE.search(unescape(description.value))
|
||||
if match:
|
||||
parts.append(" ".join(match.group(0).split()))
|
||||
location = _first(event, "LOCATION")
|
||||
if location is not None:
|
||||
flat = " ".join(unescape(location.value).split())
|
||||
if flat:
|
||||
parts.append(flat)
|
||||
return _flat(", ".join(parts), PLACE_MAX)
|
||||
|
||||
|
||||
def events_in(text: str, *, zone: tzinfo, since: datetime, days: int) -> list[Event]:
|
||||
"""События фида, начинающиеся в окне `[since, since + days]`, с повторами."""
|
||||
end = since + timedelta(days=days)
|
||||
day_start = since.astimezone(zone).replace(
|
||||
hour=0, minute=0, second=0, microsecond=0
|
||||
)
|
||||
parsed = vevents(unfold(text))
|
||||
moved: dict[str, set[datetime]] = {}
|
||||
for event in parsed:
|
||||
uid = _first(event, "UID")
|
||||
if uid is not None and "RECURRENCE-ID" in event:
|
||||
moved.setdefault(uid.value, set()).update(
|
||||
_instants(event, "RECURRENCE-ID", zone)
|
||||
)
|
||||
out: list[Event] = []
|
||||
for event in parsed:
|
||||
status = _first(event, "STATUS")
|
||||
dtstart = _first(event, "DTSTART")
|
||||
if dtstart is None or (
|
||||
status is not None and status.value.upper() == "CANCELLED"
|
||||
):
|
||||
continue
|
||||
parsed_start = moment(dtstart, dtstart.value, zone)
|
||||
if parsed_start is None:
|
||||
continue
|
||||
start, all_day = parsed_start
|
||||
rrule = _first(event, "RRULE")
|
||||
if rrule is None or "RECURRENCE-ID" in event:
|
||||
starts = [start]
|
||||
skip: set[datetime] = set()
|
||||
routine = False
|
||||
else:
|
||||
rule = _rule(rrule.value)
|
||||
starts = occurrences(start, rule, zone, end=end)
|
||||
routine = is_routine(rule)
|
||||
uid = _first(event, "UID")
|
||||
skip = _instants(event, "EXDATE", zone) | moved.get(
|
||||
uid.value if uid else "", set()
|
||||
)
|
||||
title = _flat(_text(event, "SUMMARY"), TITLE_MAX) or NO_TITLE
|
||||
place = place_of(event)
|
||||
for moving in starts:
|
||||
floor = day_start if all_day else since
|
||||
if moving < floor or moving > end or moving.astimezone(UTC) in skip:
|
||||
continue
|
||||
out.append(
|
||||
Event(
|
||||
start=moving,
|
||||
title=title,
|
||||
place=place,
|
||||
all_day=all_day,
|
||||
routine=routine,
|
||||
)
|
||||
)
|
||||
return out
|
||||
|
||||
|
||||
def _text(event: Vevent, name: str) -> str:
|
||||
prop = _first(event, name)
|
||||
return prop.value if prop is not None else ""
|
||||
@@ -1,501 +0,0 @@
|
||||
"""Взаимный сторож с чужим агентом: отметка раз в сутки и тревога на молчание.
|
||||
|
||||
Договорённость с соседом (22.09.2026): в отдельной комнате вайбграма оба
|
||||
раз в сутки печатают строку `hb <ник> at=… boot=… every=… src=…`, и каждый
|
||||
следит за молчанием другого. Замолчал дольше порога - человеку соседа
|
||||
уходит сообщение, что цепь молчит.
|
||||
|
||||
Смысл сторожа в том, чтобы он не врал: прибор, который молча не сторожит,
|
||||
хуже отсутствующего - он выглядит исправным. Поэтому дефолтов здесь нет
|
||||
нигде. Период своей отметки считается из фактического крона джоба
|
||||
(`every_from_cron`), и расписание, которое не сводится к «раз в N часов»,
|
||||
даёт честное `every=unknown`, а не подставленное число. Порог тревоги -
|
||||
`every * 1.5`, где `every` взят ИЗ СТРОКИ СОСЕДА, а не из своей константы.
|
||||
Каждый прогон, в котором показание снять нельзя (окно смотрит в прошлое,
|
||||
окно не дочитано, период неизвестен, отметок не видели ни разу), говорит
|
||||
это вслух в `ack` и в лог: «в окне никого» и «окно не прочитано до конца» -
|
||||
это два РАЗНЫХ показания, и выглядеть одинаково они не должны.
|
||||
|
||||
Окно - последние `WINDOW` СООБЩЕНИЙ этой комнаты (`Vibegram.window`), а не
|
||||
«что нового с курсора»: курсор отдаёт строку соседа один раз, и следующий
|
||||
прогон на живой комнате увидел бы пустое окно.
|
||||
|
||||
Опора тревоги - `seen`, то есть когда Я ВПЕРВЫЕ увидел строку: `at=` внутри
|
||||
строки это показание соседа о себе, и остановившиеся у него часы не должны
|
||||
выглядеть как живая цепь. Окно - это последние сообщения комнаты, поэтому
|
||||
одна и та же отметка видна в нём много прогонов подряд, и новой её делает
|
||||
новый id сообщения, а не текст: двигать `seen` на старой отметке значит
|
||||
никогда не поднять тревогу в тихой комнате.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import itertools
|
||||
import json
|
||||
import re
|
||||
from dataclasses import dataclass
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from pathlib import Path # noqa: TC003 - в аннотации dataclass
|
||||
from typing import TYPE_CHECKING, Literal
|
||||
|
||||
from croniter import CroniterError, croniter
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from collections.abc import Sequence
|
||||
from datetime import tzinfo
|
||||
|
||||
from beaver_agent.hands.vibegram import Event
|
||||
|
||||
__all__ = [
|
||||
"BOOT",
|
||||
"FACTOR",
|
||||
"PEER",
|
||||
"WINDOW",
|
||||
"Beat",
|
||||
"Report",
|
||||
"Watch",
|
||||
"ack_line",
|
||||
"alarm_text",
|
||||
"beat_line",
|
||||
"drill",
|
||||
"every_from_cron",
|
||||
"look",
|
||||
"parse_beat",
|
||||
]
|
||||
|
||||
PEER = "claude-kai"
|
||||
"""Чей `hb` сторожим. Ник соседа стоит и в его строке, и в нашем `ack`."""
|
||||
WINDOW = 25
|
||||
"""Сколько последних сообщений комнаты просим явно: молча опираться на чужой
|
||||
дефолт в стороже нельзя - размер окна едет в `ack`."""
|
||||
FACTOR = 1.5
|
||||
"""Порог молчания = заявленный соседом период × это. Одна потерянная строка
|
||||
не должна поднимать тревогу, две подряд - должны."""
|
||||
UNARMED_GRACE = timedelta(days=7)
|
||||
"""Сколько терпим `armed=no`, прежде чем сказать человеку, что кольцо так и
|
||||
не заработало: недостроенное иначе тихо становится постоянным."""
|
||||
REPEAT = timedelta(hours=24)
|
||||
"""Тревога повторяется не чаще этого, а не каждый прогон."""
|
||||
PROBES = 5
|
||||
"""Сколько срабатываний крона сверяем между собой, выводя период."""
|
||||
STATE_VERSION = 1
|
||||
|
||||
BOOT = datetime.now(UTC)
|
||||
"""Время старта процесса: модуль импортируется при сборке конфига gateway."""
|
||||
|
||||
_FIELD = re.compile(r"(\w+)=(\S+)")
|
||||
_UNITS = {"h": 3600, "m": 60, "s": 1}
|
||||
_SPAN = re.compile(r"^(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?$")
|
||||
|
||||
|
||||
def _iso(when: datetime | None) -> str | None:
|
||||
if when is None:
|
||||
return None
|
||||
return when.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
|
||||
|
||||
|
||||
def _parse_iso(raw: str | None) -> datetime | None:
|
||||
if not raw:
|
||||
return None
|
||||
try:
|
||||
when = datetime.fromisoformat(raw)
|
||||
except ValueError:
|
||||
return None
|
||||
return when if when.tzinfo else when.replace(tzinfo=UTC)
|
||||
|
||||
|
||||
def parse_span(raw: str) -> timedelta | None:
|
||||
"""`24h`, `90m`, `36h30m` - в timedelta; `unknown` и мусор - в None."""
|
||||
match = _SPAN.fullmatch(raw.strip())
|
||||
if match is None or not any(match.groups()):
|
||||
return None
|
||||
seconds = sum(
|
||||
int(value) * _UNITS[unit]
|
||||
for value, unit in zip(match.groups(), "hms", strict=True)
|
||||
if value
|
||||
)
|
||||
return timedelta(seconds=seconds) or None
|
||||
|
||||
|
||||
def span(delta: timedelta | None) -> str:
|
||||
"""Период в строку: неизвестный период так и называется, а не молчит."""
|
||||
if delta is None:
|
||||
return "unknown"
|
||||
seconds = int(delta.total_seconds())
|
||||
if seconds % 3600 == 0:
|
||||
return f"{seconds // 3600}h"
|
||||
if seconds % 60 == 0:
|
||||
return f"{seconds // 60}m"
|
||||
return f"{seconds}s"
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Beat:
|
||||
"""Разобранная строка отметки. `at` не читается - строка всё равно жива."""
|
||||
|
||||
nick: str
|
||||
at: datetime | None
|
||||
boot: datetime | None
|
||||
every: timedelta | None
|
||||
every_raw: str
|
||||
|
||||
|
||||
def parse_beat(text: str, kind: str = "hb") -> Beat | None:
|
||||
"""Строку `hb <ник> ключ=значение …` из текста события; иначе None.
|
||||
|
||||
Текст события хаба отрендерен как `<кто>: <тело>`, поэтому ищем метку
|
||||
внутри строки, а не с её начала.
|
||||
"""
|
||||
head = re.search(rf"(?:^|\s){re.escape(kind)}\s+(\S+)", text)
|
||||
if head is None:
|
||||
return None
|
||||
fields = dict(_FIELD.findall(text[head.end() :]))
|
||||
every_raw = fields.get("every", "")
|
||||
return Beat(
|
||||
nick=head.group(1),
|
||||
at=_parse_iso(fields.get("at")),
|
||||
boot=_parse_iso(fields.get("boot")),
|
||||
every=parse_span(every_raw) if every_raw else None,
|
||||
every_raw=every_raw or "unknown",
|
||||
)
|
||||
|
||||
|
||||
def every_from_cron(
|
||||
expression: str | None,
|
||||
tz: tzinfo,
|
||||
*,
|
||||
now: datetime | None = None,
|
||||
grain: timedelta = timedelta(hours=1),
|
||||
) -> timedelta | None:
|
||||
"""Шаг крона, если он сводится к «раз в N `grain`»; иначе None.
|
||||
|
||||
Считаем по стенным часам зоны, в которой планировщик читает кроны:
|
||||
суточный крон - это 24 часа и в сутки перевода стрелок тоже, а вот
|
||||
`0 2,8,12,16,20 * * *` не сводится ни к какому N и даёт None. `grain`
|
||||
по умолчанию час - такой период печатается в отметке соседу; сторожу
|
||||
прогонов нужен и `*/10`, он просит минуту.
|
||||
"""
|
||||
if not expression:
|
||||
return None
|
||||
start = (now or datetime.now(UTC)).astimezone(tz).replace(tzinfo=None)
|
||||
try:
|
||||
clock = croniter(expression, start_time=start)
|
||||
fires = [clock.get_next(datetime) for _ in range(PROBES + 1)]
|
||||
except (CroniterError, ValueError):
|
||||
return None
|
||||
steps = {b - a for a, b in itertools.pairwise(fires)}
|
||||
if len(steps) != 1:
|
||||
return None
|
||||
step = steps.pop()
|
||||
return step if step % grain == timedelta(0) else None
|
||||
|
||||
|
||||
def beat_line(
|
||||
*, nick: str, at: datetime, boot: datetime, every: timedelta | None
|
||||
) -> str:
|
||||
"""Своя отметка. Период не выведен - так и пишем, числа не выдумываем."""
|
||||
return (
|
||||
f"hb {nick} at={_iso(at)} boot={_iso(boot)} "
|
||||
f"every={span(every)} src={'cron' if every else 'none'}"
|
||||
)
|
||||
|
||||
|
||||
def ack_line(
|
||||
*,
|
||||
peer: str,
|
||||
last: datetime | None,
|
||||
seen: datetime | None,
|
||||
res: timedelta | None,
|
||||
window: int,
|
||||
stale: bool,
|
||||
armed: bool,
|
||||
threshold: timedelta | None,
|
||||
fallback: bool,
|
||||
full: bool,
|
||||
alert: Literal["fired", "held", "none"],
|
||||
) -> str:
|
||||
"""Расписка о прогоне в комнату: что видели, чем мерили и что решили.
|
||||
|
||||
`win=` - про само окно: `25` это «последние 25 сообщений комнаты прочитаны
|
||||
целиком», `25/partial` - «дочитать историю не удалось», `stale` - «окно
|
||||
смотрит в прошлое». Пустое окно при `partial` ничего не доказывает.
|
||||
|
||||
`alert=` - РЕШЕНИЕ ПРИБОРА в этом прогоне, а не факт того, что человек
|
||||
сосед что-то получил: `fired` - тревога (`silence` или `unarmed`) в этом
|
||||
прогоне взята и отдана дальше, `held` - порог пройден, но тревога
|
||||
подавлена как повтор (предыдущая уходила меньше `REPEAT` назад), `none` -
|
||||
тревоги нет. Доставка решается за пределами сторожа - мастером и
|
||||
диспетчером, - и её отказ виден в логе, а не тут: без арифметики соседу
|
||||
видно было только, что мы что-то посчитали, но не что мы из этого поняли.
|
||||
"""
|
||||
mark = span(threshold) + ("-fallback" if fallback and threshold else "")
|
||||
read = "stale" if stale else f"{window}" if full else f"{window}/partial"
|
||||
return (
|
||||
f"ack {peer} last={_iso(last) or ('never' if not armed else 'unknown')} "
|
||||
f"seen={_iso(seen) or 'never'} res={span(res)} "
|
||||
f"win={read} armed={'yes' if armed else 'no'} "
|
||||
f"thr={mark} alert={alert}"
|
||||
)
|
||||
|
||||
|
||||
def drill(path: Path, *, now: datetime, tz: tzinfo) -> bool:
|
||||
"""Стоит ли сегодняшняя дата в файле флага учений.
|
||||
|
||||
Файл - список дат `YYYY-MM-DD`, по одной на строку; дата - локальная дата
|
||||
прогона в зоне планировщика, той же, в которой читаются кроны. Файла нет,
|
||||
он пуст или нечитаем - учений нет, и отметка уходит как обычно: флаг
|
||||
выключает прибор, поэтому его отсутствие должно значить «работаем».
|
||||
"""
|
||||
try:
|
||||
raw = path.read_text(encoding="utf-8")
|
||||
except OSError:
|
||||
return False
|
||||
today = now.astimezone(tz).strftime("%Y-%m-%d")
|
||||
return today in {line.strip() for line in raw.splitlines()}
|
||||
|
||||
|
||||
@dataclass(slots=True)
|
||||
class Watch:
|
||||
"""Состояние между прогонами: файл на диске, переживает передеплой."""
|
||||
|
||||
path: Path
|
||||
at: datetime | None = None
|
||||
"""`at=` из последней виденной отметки соседа - его показание о себе."""
|
||||
seen: datetime | None = None
|
||||
"""Когда МЫ увидели ту отметку. На это опирается тревога."""
|
||||
every: timedelta | None = None
|
||||
"""Последний период, который сосед назвал читаемым числом."""
|
||||
every_unknown: bool = False
|
||||
"""В последней отметке стояло `every=unknown`: порог взят с запасом назад."""
|
||||
beat_id: int = 0
|
||||
"""id сообщения с последней зачтённой отметкой: по нему видно, что отметка
|
||||
в окне новая, а не та же. Нуль - поля в файле не было (состояние старое)
|
||||
или отметок не видели ни разу."""
|
||||
top: int = 0
|
||||
"""Максимальный id, который мы видели. Поехал назад - окно смотрит в прошлое."""
|
||||
alerted: datetime | None = None
|
||||
unarmed_since: datetime | None = None
|
||||
unarmed_told: bool = False
|
||||
|
||||
@classmethod
|
||||
def load(cls, path: Path) -> Watch:
|
||||
try:
|
||||
raw = json.loads(path.read_text(encoding="utf-8"))
|
||||
except (OSError, ValueError):
|
||||
return cls(path=path)
|
||||
if raw.get("version") != STATE_VERSION:
|
||||
return cls(path=path)
|
||||
every = raw.get("every")
|
||||
return cls(
|
||||
path=path,
|
||||
at=_parse_iso(raw.get("at")),
|
||||
seen=_parse_iso(raw.get("seen")),
|
||||
every=timedelta(seconds=every) if every else None,
|
||||
every_unknown=bool(raw.get("every_unknown")),
|
||||
beat_id=int(raw.get("beat_id", 0)),
|
||||
top=int(raw.get("top", 0)),
|
||||
alerted=_parse_iso(raw.get("alerted")),
|
||||
unarmed_since=_parse_iso(raw.get("unarmed_since")),
|
||||
unarmed_told=bool(raw.get("unarmed_told")),
|
||||
)
|
||||
|
||||
def save(self) -> None:
|
||||
body = {
|
||||
"version": STATE_VERSION,
|
||||
"at": _iso(self.at),
|
||||
"seen": _iso(self.seen),
|
||||
"every": int(self.every.total_seconds()) if self.every else None,
|
||||
"every_unknown": self.every_unknown,
|
||||
"beat_id": self.beat_id,
|
||||
"top": self.top,
|
||||
"alerted": _iso(self.alerted),
|
||||
"unarmed_since": _iso(self.unarmed_since),
|
||||
"unarmed_told": self.unarmed_told,
|
||||
}
|
||||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||||
tmp = self.path.with_suffix(".tmp")
|
||||
tmp.write_text(json.dumps(body, ensure_ascii=False, indent=1), encoding="utf-8")
|
||||
tmp.replace(self.path)
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Report:
|
||||
"""Что решил один прогон сторожа."""
|
||||
|
||||
ack: str
|
||||
stale: bool
|
||||
full: bool
|
||||
"""Окно дочитано до конца истории комнаты: пустое окно - это показание."""
|
||||
armed: bool
|
||||
heard: bool
|
||||
"""Видели ли в окне хоть что-то от соседа - `hb` или его `ack`."""
|
||||
age: timedelta | None
|
||||
threshold: timedelta | None
|
||||
alarm: Literal["silence", "unarmed"] | None
|
||||
note: str
|
||||
"""Строка для лога: почему прогон решил именно так."""
|
||||
|
||||
|
||||
def _is_new_beat(state: Watch, eid: int, beat: Beat) -> bool:
|
||||
"""Впервые ли мы видим ЭТУ отметку соседа.
|
||||
|
||||
Различитель - id сообщения: `at=` внутри строки это показание соседа о
|
||||
себе, и повторить его он может как угодно. Нуля в `beat_id` два повода:
|
||||
отметок не видели ни разу (тогда любая - новая) и состояние записано до
|
||||
появления поля - там единственное, чем можно сверить отметку со зачтённой,
|
||||
это её `at`, и одного прогона хватает, чтобы запомнить id.
|
||||
"""
|
||||
if state.beat_id:
|
||||
return eid > state.beat_id
|
||||
if state.seen is None:
|
||||
return True
|
||||
return beat.at != state.at
|
||||
|
||||
|
||||
def look(
|
||||
state: Watch,
|
||||
events: Sequence[Event],
|
||||
*,
|
||||
now: datetime,
|
||||
res: timedelta | None,
|
||||
full: bool,
|
||||
window: int = WINDOW,
|
||||
peer: str = PEER,
|
||||
) -> Report:
|
||||
"""Разобрать окно, обновить состояние и решить, будить ли человека.
|
||||
|
||||
`events` - последние сообщения комнаты, `full` - дочитаны ли они до конца
|
||||
истории. Параметр без дефолта нарочно: «окно полное» - это показание, и
|
||||
подставлять его молча за того, кто окно читал, здесь нельзя.
|
||||
|
||||
Состояние меняется здесь, а `alerted` / `unarmed_told` ставит джоб - и
|
||||
только когда тревога действительно ушла: несостоявшаяся доставка не
|
||||
должна заглушать следующий прогон.
|
||||
"""
|
||||
top = max((e.id for e in events), default=None)
|
||||
stale = top is not None and top < state.top
|
||||
beats = [
|
||||
(event.id, beat)
|
||||
for event, beat in ((event, parse_beat(event.text)) for event in events)
|
||||
if beat is not None and beat.nick == peer
|
||||
]
|
||||
heard = bool(beats) or any(e.nick == peer for e in events)
|
||||
if stale:
|
||||
note = f"окно поехало назад: максимальный id {top} против {state.top}"
|
||||
else:
|
||||
if top is not None:
|
||||
state.top = max(state.top, top)
|
||||
again = False
|
||||
if beats:
|
||||
eid, last = beats[-1]
|
||||
again = not _is_new_beat(state, eid, last)
|
||||
if not again:
|
||||
state.seen = now
|
||||
state.at, state.beat_id = last.at, eid
|
||||
state.every_unknown = last.every is None
|
||||
if last.every is not None:
|
||||
state.every = last.every
|
||||
read = "история дочитана" if full else "история НЕ дочитана"
|
||||
note = (
|
||||
f"отметок соседа в окне: {len(beats)} "
|
||||
f"(сообщений комнаты: {len(events)} из {window}, {read})"
|
||||
)
|
||||
if again:
|
||||
note += "; отметка та же, что в прошлый прогон - seen не двигаем"
|
||||
|
||||
armed = state.seen is not None
|
||||
threshold = state.every * FACTOR if state.every is not None else None
|
||||
age = now - state.seen if state.seen is not None else None
|
||||
|
||||
if armed:
|
||||
state.unarmed_since = None
|
||||
elif state.unarmed_since is None:
|
||||
state.unarmed_since = now
|
||||
|
||||
alarm: Literal["silence", "unarmed"] | None = None
|
||||
held = False
|
||||
if stale:
|
||||
pass
|
||||
elif not full:
|
||||
# Хвост комнаты недочитан, а недостающее - как раз самое свежее:
|
||||
# пустое окно тут не доказывает молчания соседа, оно доказывает,
|
||||
# что мы не дочитали. Показания нет - тревоги нет.
|
||||
note += "; окно не дочитано - это не показание, тревога не берётся"
|
||||
elif not armed:
|
||||
if (
|
||||
not state.unarmed_told
|
||||
and state.unarmed_since is not None
|
||||
and now - state.unarmed_since >= UNARMED_GRACE
|
||||
):
|
||||
alarm = "unarmed"
|
||||
elif threshold is None:
|
||||
note += "; период соседа ни разу не прочитан - мерить нечем, тревога не берётся"
|
||||
elif age is not None and age > threshold:
|
||||
if state.alerted is None or now - state.alerted >= REPEAT:
|
||||
alarm = "silence"
|
||||
else:
|
||||
held = True
|
||||
note += "; тревога уже уходила меньше суток назад"
|
||||
|
||||
return Report(
|
||||
ack=ack_line(
|
||||
peer=peer,
|
||||
last=state.at,
|
||||
seen=state.seen,
|
||||
res=res,
|
||||
window=window,
|
||||
stale=stale,
|
||||
armed=armed,
|
||||
threshold=threshold,
|
||||
fallback=state.every_unknown,
|
||||
full=full,
|
||||
alert="fired" if alarm is not None else "held" if held else "none",
|
||||
),
|
||||
stale=stale,
|
||||
full=full,
|
||||
armed=armed,
|
||||
heard=heard,
|
||||
age=age,
|
||||
threshold=threshold,
|
||||
alarm=alarm,
|
||||
note=note,
|
||||
)
|
||||
|
||||
|
||||
def alarm_text(report: Report, *, peer: str = PEER, mine_sent: bool) -> str:
|
||||
"""Текст человеку соседа. Различитель канала - последним абзацем."""
|
||||
if report.alarm == "unarmed":
|
||||
return (
|
||||
f"Сторожевое кольцо с {peer} так и не заработало: за семь суток "
|
||||
f"в сторожевой комнате не было ни одной его отметки `hb`, а значит "
|
||||
f"сторожить нечего - прибор не вооружён (`armed=no`). Свою отметку "
|
||||
f"мы печатаем и свой `ack` тоже"
|
||||
+ ("" if mine_sent else ", но сейчас она в комнату не ушла")
|
||||
+ ". Проверить стоит три вещи: та ли это комната (токен "
|
||||
"`VIBEGRAM_HB_TOKEN` мог остаться от другой), запустил ли сосед "
|
||||
"свою половину, и виден ли нам вообще чужой текст в этой комнате."
|
||||
)
|
||||
age = span(report.age) if report.age else "?"
|
||||
threshold = span(report.threshold) if report.threshold else "?"
|
||||
channel = (
|
||||
"Наша собственная запись в комнату в этом же прогоне прошла, а от "
|
||||
f"{peer} нет НИ `hb`, НИ `ack` - значит канал подозревать надо раньше, "
|
||||
"чем смерть соседа: пишем мы в комнату, но чужого оттуда не читаем."
|
||||
if mine_sent and not report.heard
|
||||
else (
|
||||
"Наша собственная запись в комнату в этом прогоне НЕ прошла - "
|
||||
"первым делом канал, а не сосед."
|
||||
if not mine_sent
|
||||
else f"Что-то от {peer} в окне было (его `ack` или другая строка), "
|
||||
"так что канал скорее жив, а молчит именно отметка."
|
||||
)
|
||||
)
|
||||
return (
|
||||
f"Сторожевая цепь молчит: последнюю отметку `hb {peer}` мы видели "
|
||||
f"{age} назад при пороге {threshold} (порог - период из его же строки "
|
||||
"× 1.5). Причин может быть три: машина соседа, его крон, или канал - "
|
||||
f"сама комната. {channel}\n"
|
||||
f"Это дело человека {peer}, а не наше: разбудить владельца имеет смысл "
|
||||
"только чтобы он написал соседу по своему каналу. Повторно об этом "
|
||||
"молчании мы скажем не раньше чем через сутки."
|
||||
)
|
||||
@@ -1,169 +0,0 @@
|
||||
"""Home Assistant как python_tool с перечислимыми действиями.
|
||||
|
||||
Токен HA живёт в gateway и в контекст модели не попадает. Действия:
|
||||
найти сущности, посмотреть состояние, вызвать сервис, перечислить сервисы
|
||||
домена. Ничего про конфигурацию, пользователей и интеграции - только
|
||||
REST `/api/states` и `/api/services`.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from dataclasses import dataclass
|
||||
from typing import Any, Literal
|
||||
|
||||
import aiohttp
|
||||
|
||||
__all__ = ["Action", "HomeAssistant"]
|
||||
|
||||
Action = Literal["search", "state", "call", "services"]
|
||||
|
||||
SEARCH_LIMIT = 60
|
||||
ATTR_LIMIT = 25
|
||||
# Не влезает в ответ и не нужно модели: гигантские списки и бинарники.
|
||||
NOISY_ATTRS = frozenset({"entity_picture", "icon", "supported_color_modes", "options"})
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class HomeAssistant:
|
||||
url: str
|
||||
token: str
|
||||
timeout: float = 20.0
|
||||
max_chars: int = 8_000
|
||||
|
||||
async def ha(
|
||||
self,
|
||||
action: Action,
|
||||
*,
|
||||
query: str | None = None,
|
||||
entity: str | None = None,
|
||||
domain: str | None = None,
|
||||
service: str | None = None,
|
||||
data: dict[str, Any] | None = None,
|
||||
) -> str:
|
||||
"""Home Assistant - умный дом: свет, кнопки ИК-пульта, сцены, скрипты, датчики.
|
||||
|
||||
action:
|
||||
- search: сущности по подстроке в id или имени (query; пусто - все),
|
||||
сгруппированы по домену. Начни отсюда: точные entity_id нужны везде.
|
||||
- state: состояние и атрибуты одной сущности (entity).
|
||||
- call: вызвать сервис (domain, service, entity опционально, data -
|
||||
доп. поля: brightness, color_temp, …). Примеры: light/turn_on,
|
||||
light/turn_off, script/turn_on, scene/turn_on, button/press.
|
||||
- services: какие сервисы есть у домена (domain) и их поля.
|
||||
|
||||
Делай то, о чём попросили: «выключи свет» - это одна сущность или
|
||||
группа, не весь дом.
|
||||
"""
|
||||
match action:
|
||||
case "search":
|
||||
return await self._search(query or "")
|
||||
case "state":
|
||||
return await self._state(_need(entity, "entity"))
|
||||
case "call":
|
||||
return await self._call(
|
||||
_need(domain, "domain"), _need(service, "service"), entity, data
|
||||
)
|
||||
case "services":
|
||||
return await self._services(_need(domain, "domain"))
|
||||
|
||||
async def _search(self, query: str) -> str:
|
||||
states = await self._get("/api/states")
|
||||
q = query.lower()
|
||||
hits = [
|
||||
s
|
||||
for s in states
|
||||
if q in s["entity_id"].lower()
|
||||
or q in str(s.get("attributes", {}).get("friendly_name", "")).lower()
|
||||
]
|
||||
if not hits:
|
||||
return "ничего не нашлось"
|
||||
by_domain: dict[str, list[dict[str, Any]]] = {}
|
||||
for s in sorted(hits, key=lambda s: s["entity_id"]):
|
||||
by_domain.setdefault(s["entity_id"].split(".", 1)[0], []).append(s)
|
||||
lines = []
|
||||
shown = 0
|
||||
for dom, items in by_domain.items():
|
||||
lines.append(f"{dom}:")
|
||||
for s in items:
|
||||
if shown >= SEARCH_LIMIT:
|
||||
lines.append(f" … ещё {len(hits) - shown}, уточни query")
|
||||
return "\n".join(lines)
|
||||
name = s.get("attributes", {}).get("friendly_name") or ""
|
||||
lines.append(f" {s['entity_id']:40} {s['state']:12} {name}")
|
||||
shown += 1
|
||||
return "\n".join(lines)
|
||||
|
||||
async def _state(self, entity: str) -> str:
|
||||
s = await self._get(f"/api/states/{entity}")
|
||||
attrs = {
|
||||
k: v for k, v in (s.get("attributes") or {}).items() if k not in NOISY_ATTRS
|
||||
}
|
||||
lines = [f"{s['entity_id']}: {s['state']} (с {s.get('last_changed', '?')})"]
|
||||
for k, v in list(attrs.items())[:ATTR_LIMIT]:
|
||||
lines.append(f" {k}: {json.dumps(v, ensure_ascii=False)[:200]}")
|
||||
return self._clip("\n".join(lines))
|
||||
|
||||
async def _call(
|
||||
self, domain: str, service: str, entity: str | None, data: dict[str, Any] | None
|
||||
) -> str:
|
||||
body: dict[str, Any] = dict(data or {})
|
||||
if entity:
|
||||
body["entity_id"] = entity
|
||||
changed = await self._post(f"/api/services/{domain}/{service}", body)
|
||||
if not changed:
|
||||
return f"{domain}.{service}: выполнено, состояния не менялись"
|
||||
lines = [f"{domain}.{service}: выполнено, изменилось:"]
|
||||
lines.extend(f" {s['entity_id']}: {s['state']}" for s in changed[:20])
|
||||
return "\n".join(lines)
|
||||
|
||||
async def _services(self, domain: str) -> str:
|
||||
for block in await self._get("/api/services"):
|
||||
if block.get("domain") == domain:
|
||||
lines = [f"{domain}:"]
|
||||
for name, spec in sorted((block.get("services") or {}).items()):
|
||||
fields = ", ".join((spec.get("fields") or {}).keys())
|
||||
lines.append(
|
||||
f" {name}: {spec.get('description') or ''}".rstrip()
|
||||
+ (f" [{fields}]" if fields else "")
|
||||
)
|
||||
return self._clip("\n".join(lines))
|
||||
return f"домена {domain} нет"
|
||||
|
||||
async def _get(self, path: str) -> Any:
|
||||
return await self._request("GET", path, None)
|
||||
|
||||
async def _post(self, path: str, body: dict[str, Any]) -> Any:
|
||||
return await self._request("POST", path, body)
|
||||
|
||||
async def _request(
|
||||
self, method: str, path: str, body: dict[str, Any] | None
|
||||
) -> Any:
|
||||
headers = {"Authorization": f"Bearer {self.token}"}
|
||||
async with (
|
||||
aiohttp.ClientSession() as http,
|
||||
http.request(
|
||||
method,
|
||||
f"{self.url.rstrip('/')}{path}",
|
||||
json=body,
|
||||
headers=headers,
|
||||
timeout=aiohttp.ClientTimeout(total=self.timeout),
|
||||
) as response,
|
||||
):
|
||||
text = await response.text()
|
||||
if response.status >= 400:
|
||||
msg = f"Home Assistant {method} {path}: {response.status} {text[:300]}"
|
||||
raise RuntimeError(msg)
|
||||
return json.loads(text) if text else None
|
||||
|
||||
def _clip(self, text: str) -> str:
|
||||
if len(text) <= self.max_chars:
|
||||
return text
|
||||
return text[: self.max_chars] + "\n…[обрезано]"
|
||||
|
||||
|
||||
def _need(value: str | None, name: str) -> str:
|
||||
if not value:
|
||||
msg = f"для этого действия нужен параметр {name}"
|
||||
raise ValueError(msg)
|
||||
return value
|
||||
@@ -1,406 +0,0 @@
|
||||
"""Komodo как python_tool с перечислимыми действиями.
|
||||
|
||||
Ключ живёт в gateway и в контекст модели не попадает. В перечислении нет
|
||||
`Prune*`, `Destroy*`, `DeleteServer` и терминала хоста; `exec` - это
|
||||
`docker exec` в контейнер, не шелл на сервере, и контейнеры из
|
||||
``exec_deny`` (periphery с docker.sock - это и есть хост) ему не даются.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import fnmatch
|
||||
import json
|
||||
import re
|
||||
import time
|
||||
from dataclasses import dataclass
|
||||
from datetime import UTC, datetime
|
||||
from typing import Any, Literal
|
||||
|
||||
import aiohttp
|
||||
|
||||
__all__ = ["Action", "Komodo"]
|
||||
|
||||
Action = Literal[
|
||||
"status",
|
||||
"stacks",
|
||||
"containers",
|
||||
"logs",
|
||||
"search_logs",
|
||||
"updates",
|
||||
"update",
|
||||
"deploy",
|
||||
"restart",
|
||||
"exec",
|
||||
]
|
||||
|
||||
ANSI = re.compile(r"\x1b\[[0-9;?]*[ -/]*[@-~]")
|
||||
EXIT_MARK = "__KOMODO_EXIT_CODE:"
|
||||
NOT_RUNNING_LIMIT = 15
|
||||
UPDATES_LIMIT = 15
|
||||
UPDATES_MAX = 200
|
||||
|
||||
LIST_LIMIT = 500
|
||||
LIST_PAGES = 20
|
||||
"""Komodo режет любой ``List*`` до своего ``default_pagination_limit`` (у нас
|
||||
50) и молчит об этом: ответ - просто короткий массив, неотличимый от полного.
|
||||
Поэтому листаем сами, а не верим первой странице."""
|
||||
|
||||
RESOURCE_LISTS = (
|
||||
"ListStacks",
|
||||
"ListServers",
|
||||
"ListRepos",
|
||||
"ListResourceSyncs",
|
||||
"ListProcedures",
|
||||
"ListActions",
|
||||
"ListAlerters",
|
||||
"ListDeployments",
|
||||
"ListBuilds",
|
||||
)
|
||||
"""Журнал операций называет ресурс id, а не именем: отсюда берём словарь."""
|
||||
|
||||
SCOPE_NOTE = "список ограничен правами ключа: вне их Komodo ресурсы не показывает"
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Komodo:
|
||||
url: str
|
||||
key: str
|
||||
secret: str
|
||||
exec_deny: tuple[str, ...] = ("*periphery*", "*komodo*")
|
||||
terminal: str = "beaver"
|
||||
shell: str = "env PAGER=cat GIT_PAGER=cat TERM=dumb sh"
|
||||
"""Terminal is a tty: without ``PAGER=cat`` psql/git open a pager and
|
||||
wait for a key forever, wedging the terminal."""
|
||||
timeout: float = 120.0
|
||||
wait: float = 180.0
|
||||
max_chars: int = 12_000
|
||||
|
||||
async def komodo(
|
||||
self,
|
||||
action: Action,
|
||||
*,
|
||||
stack: str | None = None,
|
||||
service: str | None = None,
|
||||
container: str | None = None,
|
||||
command: str | None = None,
|
||||
terms: str | None = None,
|
||||
tail: int = 100,
|
||||
update: str | None = None,
|
||||
server: str | None = None,
|
||||
limit: int = UPDATES_LIMIT,
|
||||
operation: str | None = None,
|
||||
resource: str | None = None,
|
||||
) -> str:
|
||||
"""Прод через Komodo: посмотреть, а по просьбе Бобра - подействовать.
|
||||
|
||||
action:
|
||||
- status: серверы и стеки не в running.
|
||||
- stacks: все стеки - сервер, состояние, есть ли незадеплоенные коммиты.
|
||||
- containers: контейнеры сервера (server; без него - все серверы).
|
||||
- logs: логи стека (stack, service опционально, tail строк).
|
||||
- search_logs: поиск по логам стека (stack, terms - слова через пробел).
|
||||
- updates: последние операции - кто, что, статус. limit записей
|
||||
(по умолчанию 15, максимум 200), operation - подстрока типа операции
|
||||
(deploy, sync, restart), resource - имя стека, сервера, репозитория.
|
||||
Шапка говорит, какой отрезок журнала показан: журнал длинный, и
|
||||
«под фильтр ничего не попало» - это не «операций больше не было».
|
||||
- update: подробности одной операции по id (update).
|
||||
- deploy / restart: стек целиком или один service; ждёт исхода до 3 мин.
|
||||
- exec: команда внутри контейнера (container, command; server, если имя
|
||||
контейнера есть на нескольких серверах). Это `docker exec` от
|
||||
пользователя контейнера, свежий шелл на каждый вызов, без tty-пейджера.
|
||||
Лимит ~2 мин: долгое запускай в фон с выводом в файл и читай файл.
|
||||
|
||||
Деплой и рестарт - только когда об этом попросили, не «заодно».
|
||||
"""
|
||||
match action:
|
||||
case "status":
|
||||
return await self._status()
|
||||
case "stacks":
|
||||
return await self._stacks()
|
||||
case "containers":
|
||||
return await self._containers(server)
|
||||
case "logs":
|
||||
return await self._logs(_need(stack, "stack"), service, tail)
|
||||
case "search_logs":
|
||||
return await self._search(
|
||||
_need(stack, "stack"), _need(terms, "terms"), service
|
||||
)
|
||||
case "updates":
|
||||
return await self._updates(limit, operation, resource)
|
||||
case "update":
|
||||
return await self._update(_need(update, "update"))
|
||||
case "deploy":
|
||||
return await self._run("DeployStack", _need(stack, "stack"), service)
|
||||
case "restart":
|
||||
return await self._run("RestartStack", _need(stack, "stack"), service)
|
||||
case "exec":
|
||||
return await self._exec(
|
||||
_need(container, "container"), _need(command, "command"), server
|
||||
)
|
||||
|
||||
async def execute(self, operation: str, params: dict[str, Any]) -> dict[str, Any]:
|
||||
return await self._json("execute", {"type": operation, "params": params})
|
||||
|
||||
async def read(self, request: str, params: dict[str, Any]) -> Any:
|
||||
return await self._json("read", {"type": request, "params": params})
|
||||
|
||||
async def _status(self) -> str:
|
||||
servers, stacks = await asyncio.gather(
|
||||
self.listing("ListServers"), self.listing("ListStacks")
|
||||
)
|
||||
lines = [f"{s['name']:24} {s['info']['state']}" for s in servers]
|
||||
bad = [s for s in stacks if s["info"]["state"] != "running"]
|
||||
lines.append(f"стеков: {len(stacks)}, не running: {len(bad)}")
|
||||
lines.extend(
|
||||
f" {s['info']['state']:12} {s['name']} @{s['info'].get('server_name')}"
|
||||
for s in bad[:NOT_RUNNING_LIMIT]
|
||||
)
|
||||
if len(bad) > NOT_RUNNING_LIMIT:
|
||||
lines.append(
|
||||
f"показаны {NOT_RUNNING_LIMIT} из {len(bad)}, остальные скрыты лимитом"
|
||||
)
|
||||
lines.append(SCOPE_NOTE)
|
||||
return "\n".join(lines)
|
||||
|
||||
async def _stacks(self) -> str:
|
||||
stacks = await self.listing("ListStacks")
|
||||
lines = []
|
||||
for s in sorted(stacks, key=lambda s: s["name"]):
|
||||
info = s["info"]
|
||||
behind = info.get("latest_hash") and info.get("deployed_hash") != info.get(
|
||||
"latest_hash"
|
||||
)
|
||||
lines.append(
|
||||
f"{info['state']:12} {s['name']:28} @{info.get('server_name')}"
|
||||
+ (" (есть незадеплоенные коммиты)" if behind else "")
|
||||
)
|
||||
lines.append(f"стеков: {len(stacks)}; {SCOPE_NOTE}")
|
||||
return "\n".join(lines)
|
||||
|
||||
async def _containers(self, server: str | None) -> str:
|
||||
names = (
|
||||
[server]
|
||||
if server
|
||||
else [s["name"] for s in await self.listing("ListServers")]
|
||||
)
|
||||
lines = []
|
||||
for name in names:
|
||||
containers = await self.listing("ListDockerContainers", {"server": name})
|
||||
lines.append(f"{name}:")
|
||||
lines.extend(
|
||||
f" {c['state']:10} {c['name']:36} {c.get('status', '')}"
|
||||
for c in sorted(containers, key=lambda c: c["name"])
|
||||
)
|
||||
return "\n".join(lines)
|
||||
|
||||
async def _logs(self, stack: str, service: str | None, tail: int) -> str:
|
||||
log = await self.read(
|
||||
"GetStackLog",
|
||||
{"stack": stack, "services": [service] if service else [], "tail": tail},
|
||||
)
|
||||
return self._clip(_log_text(log))
|
||||
|
||||
async def _search(self, stack: str, terms: str, service: str | None) -> str:
|
||||
log = await self.read(
|
||||
"SearchStackLog",
|
||||
{
|
||||
"stack": stack,
|
||||
"services": [service] if service else [],
|
||||
"terms": terms.split(),
|
||||
},
|
||||
)
|
||||
return self._clip(_log_text(log))
|
||||
|
||||
async def _updates(
|
||||
self, limit: int, operation: str | None, resource: str | None
|
||||
) -> str:
|
||||
want = min(max(limit, 1), UPDATES_MAX)
|
||||
names = await self._resource_names()
|
||||
query: dict[str, Any] = {}
|
||||
applied = []
|
||||
if operation:
|
||||
query["operation"] = {"$regex": re.escape(operation), "$options": "i"}
|
||||
applied.append(f"операция ~{operation}")
|
||||
if resource:
|
||||
ids = [i for i, name in names.items() if resource.lower() in name.lower()]
|
||||
if not ids:
|
||||
return (
|
||||
f"ресурса ~{resource} ключу руки не видно: "
|
||||
"либо имя другое, либо он вне прав ключа"
|
||||
)
|
||||
query["target.id"] = {"$in": ids}
|
||||
applied.append(f"ресурс ~{resource} ({len(ids)} шт)")
|
||||
updates, more = await self._update_pages(query, want)
|
||||
|
||||
head = [f"операций: {len(updates)}"]
|
||||
if updates:
|
||||
head.append(
|
||||
f"{_ts(updates[-1]['start_ts'])} … {_ts(updates[0]['start_ts'])}"
|
||||
)
|
||||
head.append("раньше в журнале есть ещё" if more else "это весь журнал")
|
||||
lines = [", ".join(head)]
|
||||
lines.append(
|
||||
"фильтрует Komodo: " + "; ".join(applied)
|
||||
if applied
|
||||
else "фильтра нет: это просто хвост журнала"
|
||||
)
|
||||
if want != limit:
|
||||
lines.append(f"запрошено {limit} записей, предел руки {want}")
|
||||
unseen = sum(1 for u in updates if u["target"]["id"] not in names)
|
||||
if unseen:
|
||||
lines.append(
|
||||
f"записей о невидимых ключу ресурсах: {unseen} - id вместо имени"
|
||||
)
|
||||
lines.extend(_update_line(u, names) for u in updates)
|
||||
return "\n".join(lines)
|
||||
|
||||
async def _update_pages(
|
||||
self, query: dict[str, Any], want: int
|
||||
) -> tuple[list[dict[str, Any]], bool]:
|
||||
"""Страница ListUpdates - ровно 100 записей, limit там не работает."""
|
||||
out: list[dict[str, Any]] = []
|
||||
page: int | None = 0
|
||||
while page is not None and len(out) < want:
|
||||
body: dict[str, Any] = {"page": page}
|
||||
if query:
|
||||
body["query"] = query
|
||||
answer = await self.read("ListUpdates", body)
|
||||
out.extend(answer["updates"])
|
||||
page = answer.get("next_page")
|
||||
return out[:want], len(out) > want or page is not None
|
||||
|
||||
async def _resource_names(self) -> dict[str, str]:
|
||||
lists = await asyncio.gather(*(self.listing(r) for r in RESOURCE_LISTS))
|
||||
return {r["id"]: r["name"] for rows in lists for r in rows}
|
||||
|
||||
async def _update(self, update_id: str) -> str:
|
||||
return self._clip(
|
||||
_update_detail(await self.read("GetUpdate", {"id": update_id}))
|
||||
)
|
||||
|
||||
async def _run(self, operation: str, stack: str, service: str | None) -> str:
|
||||
receipt = await self.execute(
|
||||
operation, {"stack": stack, "services": [service] if service else []}
|
||||
)
|
||||
update_id = receipt.get("id") or receipt.get("_id", {}).get("$oid")
|
||||
if not update_id:
|
||||
return f"{operation} {stack}: Komodo вернул {receipt!r}"
|
||||
deadline = time.monotonic() + self.wait
|
||||
while time.monotonic() < deadline:
|
||||
await asyncio.sleep(5)
|
||||
current = await self.read("GetUpdate", {"id": update_id})
|
||||
if current.get("status") == "Complete":
|
||||
return self._clip(_update_detail(current))
|
||||
return f"{operation} {stack}: ещё идёт, update={update_id} - проверь позже"
|
||||
|
||||
async def _exec(self, container: str, command: str, server: str | None) -> str:
|
||||
if any(fnmatch.fnmatchcase(container, p) for p in self.exec_deny):
|
||||
return f"exec в {container} запрещён: это контейнер инфраструктуры"
|
||||
server = server or await self._server_of(container)
|
||||
if server is None:
|
||||
return f"контейнер {container} не найден ни на одном сервере"
|
||||
body = {
|
||||
"target": {
|
||||
"type": "Container",
|
||||
"params": {"server": server, "container": container},
|
||||
},
|
||||
"terminal": self.terminal,
|
||||
"command": command,
|
||||
"init": {"command": self.shell, "recreate": "Always"},
|
||||
}
|
||||
status, text = await self._post("terminal/execute", body)
|
||||
if status != 200:
|
||||
return f"exec {container}: Komodo {status}: {text[:500]}"
|
||||
output, _, code = ANSI.sub("", text).rpartition(EXIT_MARK)
|
||||
header = f"[{container}@{server}] exit {code.strip() or '?'}"
|
||||
return f"{header}\n{self._clip(output.strip())}"
|
||||
|
||||
async def _server_of(self, container: str) -> str | None:
|
||||
for s in await self.listing("ListServers"):
|
||||
containers = await self.listing(
|
||||
"ListDockerContainers", {"server": s["name"]}
|
||||
)
|
||||
if any(c["name"] == container for c in containers):
|
||||
return s["name"]
|
||||
return None
|
||||
|
||||
async def listing(
|
||||
self, request: str, params: dict[str, Any] | None = None
|
||||
) -> list[Any]:
|
||||
"""Любой ``List*`` целиком: страницами, пока Komodo не отдаст неполную.
|
||||
|
||||
Публичная: этим же листанием ходят джобы, второго такого не пишем.
|
||||
"""
|
||||
out: list[Any] = []
|
||||
for page in range(LIST_PAGES):
|
||||
chunk = await self.read(
|
||||
request, (params or {}) | {"page": page, "limit": LIST_LIMIT}
|
||||
)
|
||||
out.extend(chunk)
|
||||
if len(chunk) < LIST_LIMIT:
|
||||
break
|
||||
return out
|
||||
|
||||
async def _json(self, route: str, body: dict[str, Any]) -> Any:
|
||||
status, text = await self._post(route, body)
|
||||
if status != 200:
|
||||
msg = f"Komodo {route} {body.get('type')}: {status} {text[:500]}"
|
||||
raise RuntimeError(msg)
|
||||
return json.loads(text)
|
||||
|
||||
async def _post(self, route: str, body: dict[str, Any]) -> tuple[int, str]:
|
||||
headers = {"X-Api-Key": self.key, "X-Api-Secret": self.secret}
|
||||
async with (
|
||||
aiohttp.ClientSession() as http,
|
||||
http.post(
|
||||
f"{self.url.rstrip('/')}/{route}",
|
||||
json=body,
|
||||
headers=headers,
|
||||
timeout=aiohttp.ClientTimeout(total=self.timeout),
|
||||
) as response,
|
||||
):
|
||||
return response.status, await response.text()
|
||||
|
||||
def _clip(self, text: str) -> str:
|
||||
if len(text) <= self.max_chars:
|
||||
return text
|
||||
head, tail = self.max_chars * 2 // 3, self.max_chars // 3
|
||||
cut = len(text) - head - tail
|
||||
return f"{text[:head]}\n…[обрезано {cut} символов]…\n{text[-tail:]}"
|
||||
|
||||
|
||||
def _need(value: str | None, name: str) -> str:
|
||||
if not value:
|
||||
msg = f"для этого действия нужен параметр {name}"
|
||||
raise ValueError(msg)
|
||||
return value
|
||||
|
||||
|
||||
def _log_text(log: dict[str, Any]) -> str:
|
||||
if "error" in log:
|
||||
return f"Komodo: {log['error']}"
|
||||
return ANSI.sub("", (log.get("stdout") or "") + (log.get("stderr") or "")).strip()
|
||||
|
||||
|
||||
def _ts(ms: int) -> str:
|
||||
return datetime.fromtimestamp(ms / 1000, tz=UTC).strftime("%m-%d %H:%M")
|
||||
|
||||
|
||||
def _update_line(u: dict[str, Any], names: dict[str, str]) -> str:
|
||||
ok = "ok" if u.get("success") else "FAIL"
|
||||
target = names.get(u["target"]["id"], u["target"]["id"])
|
||||
head = f"{_ts(u['start_ts'])} {u['operation']:20} {target:26} {u['status']:10} {ok}"
|
||||
return f"{head} user={u.get('username')} id={u.get('id')}"
|
||||
|
||||
|
||||
def _update_detail(u: dict[str, Any]) -> str:
|
||||
lines = [f"{u['operation']} {u['status']} {'ok' if u.get('success') else 'FAIL'}"]
|
||||
for stage in u.get("logs", []):
|
||||
out = ANSI.sub(
|
||||
"", (stage.get("stdout") or "") + " " + (stage.get("stderr") or "")
|
||||
)
|
||||
lines.append(f"-- {stage['stage']} {'ok' if stage['success'] else 'FAIL'}")
|
||||
lines.append(re.sub("<[^>]+>", "", out).strip()[:1500])
|
||||
return "\n".join(lines)
|
||||
@@ -1,229 +0,0 @@
|
||||
"""алерты Komodo для диспетчера - что доехать до мастера, когда и как.
|
||||
|
||||
Вебхук `/hooks/komodo` получает всё, что шлёт Komodo (типы алертов у
|
||||
алертера не перечислены намеренно). Сюда мастеру нужна малая часть, и не
|
||||
сразу: `ServerUnreachable` и смены состояния стеков - флап, который через
|
||||
минуту сам отбивается («отбой» от Komodo приходит следом), а срочный
|
||||
инжект прерывает тёрн и стоит токенов. Поэтому такие алерты выдерживаются
|
||||
(`HOLD`), и по истечении выдержки состояние перепроверяется по API: если
|
||||
всё уже running - алерт молча выбрасывается; если нет - мастер получает
|
||||
срочный инжект. Информационные типы (обновления образов, расписания,
|
||||
дрейф синка) не доезжают вообще - их читает Бобёр в healthbot.
|
||||
|
||||
Komodo создаёт `StackStateChange`/`ContainerStateChange` сразу с
|
||||
`resolved=true` (`resolved_ts == ts`): это факт «состояние сменилось», а
|
||||
не тревога, которую снимают. У них смотрим на `to`, не на `resolved`.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from typing import Any, Literal
|
||||
|
||||
__all__ = ["HOLD", "Alert", "AlertMemory", "Verdict", "describe", "parse", "still_bad"]
|
||||
|
||||
HOLD = timedelta(minutes=5)
|
||||
|
||||
# Не для диспетчера: Бобёр видит их в healthbot, действия по ним - его.
|
||||
INFORMATIONAL = frozenset(
|
||||
{
|
||||
"StackImageUpdateAvailable",
|
||||
"DeploymentImageUpdateAvailable",
|
||||
"StackAutoUpdated",
|
||||
"DeploymentAutoUpdated",
|
||||
"ResourceSyncPendingUpdates",
|
||||
"ScheduleRun",
|
||||
"Test",
|
||||
"Custom",
|
||||
}
|
||||
)
|
||||
# Флапает: ждать HOLD и перепроверить, прежде чем будить мастера.
|
||||
FLAPPY = frozenset(
|
||||
{"ServerUnreachable", "StackStateChange", "ContainerStateChange", "ServerCpu"}
|
||||
)
|
||||
STATE_CHANGE = frozenset({"StackStateChange", "ContainerStateChange"})
|
||||
HEALTHY_STATES = frozenset({"running", "healthy"})
|
||||
FAILURE = frozenset(
|
||||
{"ProcedureFailed", "ActionFailed", "BuildFailed", "RepoBuildFailed"}
|
||||
)
|
||||
|
||||
Action = Literal["drop", "hold", "inject", "resolved"]
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Alert:
|
||||
kind: str
|
||||
level: str
|
||||
resolved: bool
|
||||
name: str
|
||||
server: str | None
|
||||
data: dict[str, Any]
|
||||
|
||||
@property
|
||||
def key(self) -> str:
|
||||
return f"{self.kind}:{self.server or '-'}:{self.name}"
|
||||
|
||||
@property
|
||||
def bad(self) -> bool:
|
||||
"""Тревога, а не снятие.
|
||||
|
||||
У смен состояния - по `to`, у прочих - по `resolved`.
|
||||
"""
|
||||
if self.kind in STATE_CHANGE:
|
||||
return str(self.data.get("to", "")).lower() not in HEALTHY_STATES
|
||||
return not self.resolved
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Verdict:
|
||||
action: Action
|
||||
urgency: Literal["urgent", "normal"] = "normal"
|
||||
|
||||
|
||||
@dataclass(slots=True)
|
||||
class AlertMemory:
|
||||
"""Что выдерживается и о чём мастеру уже сказали.
|
||||
|
||||
Повторы во время выдержки не дублируются, а «отбой» доезжает только
|
||||
после тревоги, которую мастер видел.
|
||||
"""
|
||||
|
||||
holding: set[str] = field(default_factory=set)
|
||||
told: dict[str, datetime] = field(default_factory=dict)
|
||||
|
||||
def verdict(self, alert: Alert) -> Verdict:
|
||||
if alert.kind in INFORMATIONAL:
|
||||
return Verdict("drop")
|
||||
if not alert.bad:
|
||||
if alert.key in self.holding:
|
||||
# Снялось, пока ждали: ни тревоги, ни отбоя.
|
||||
self.holding.discard(alert.key)
|
||||
return Verdict("drop")
|
||||
if self.told.pop(alert.key, None) is not None:
|
||||
return Verdict("resolved")
|
||||
return Verdict("drop")
|
||||
if alert.kind in FLAPPY:
|
||||
if alert.key in self.holding:
|
||||
return Verdict("drop")
|
||||
self.holding.add(alert.key)
|
||||
return Verdict("hold")
|
||||
return Verdict("inject", "normal")
|
||||
|
||||
def after_hold(self, alert: Alert, *, still_bad: bool) -> Verdict:
|
||||
self.holding.discard(alert.key)
|
||||
if not still_bad:
|
||||
return Verdict("drop")
|
||||
return Verdict("inject", "urgent")
|
||||
|
||||
def mark_told(self, alert: Alert) -> None:
|
||||
self.told[alert.key] = datetime.now(UTC)
|
||||
|
||||
|
||||
def parse(payload: dict[str, Any]) -> Alert:
|
||||
data = payload.get("data") or {}
|
||||
inner = data.get("data") if isinstance(data, dict) else None
|
||||
inner = inner if isinstance(inner, dict) else {}
|
||||
return Alert(
|
||||
kind=str(data.get("type") or "Unknown")
|
||||
if isinstance(data, dict)
|
||||
else "Unknown",
|
||||
level=str(payload.get("level") or "").upper(),
|
||||
resolved=bool(payload.get("resolved")),
|
||||
name=str(inner.get("name") or inner.get("id") or "?"),
|
||||
server=inner.get("server_name"),
|
||||
data=inner,
|
||||
)
|
||||
|
||||
|
||||
def _gb(value: Any) -> str:
|
||||
try:
|
||||
return f"{float(value):.1f} ГБ"
|
||||
except (TypeError, ValueError):
|
||||
return str(value)
|
||||
|
||||
|
||||
def _pct(value: Any) -> str:
|
||||
try:
|
||||
return f"{float(value):.0f}%"
|
||||
except (TypeError, ValueError):
|
||||
return str(value)
|
||||
|
||||
|
||||
def _err(value: Any) -> str:
|
||||
if isinstance(value, dict):
|
||||
return str(value.get("error") or value)
|
||||
return str(value or "без деталей")
|
||||
|
||||
|
||||
def describe(alert: Alert, *, held: timedelta | None = None) -> str:
|
||||
"""Одна-две строки для инжекта: что, где, с каких пор."""
|
||||
d = alert.data
|
||||
name, server = alert.name, alert.server
|
||||
where = f" на {server}" if server else ""
|
||||
since = f" уже {int(held.total_seconds() // 60)} мин" if held else ""
|
||||
match alert.kind:
|
||||
case "ServerUnreachable":
|
||||
return f"сервер {name} не отвечает{since}: {_err(d.get('err'))}"
|
||||
case "StackStateChange":
|
||||
return f"стек {name}{where}: {d.get('from')} → {d.get('to')}{since}"
|
||||
case "ContainerStateChange":
|
||||
return f"контейнер {name}{where}: {d.get('from')} → {d.get('to')}{since}"
|
||||
case "ServerCpu":
|
||||
return f"CPU на {name}: {_pct(d.get('percentage'))}{since}"
|
||||
case "ServerMem":
|
||||
return (
|
||||
f"память на {name}: {_gb(d.get('used_gb'))} из {_gb(d.get('total_gb'))}"
|
||||
)
|
||||
case "ServerDisk":
|
||||
return (
|
||||
f"диск на {name} ({d.get('path', '/')}): "
|
||||
f"{_gb(d.get('used_gb'))} из {_gb(d.get('total_gb'))}"
|
||||
)
|
||||
case "ServerVersionMismatch":
|
||||
return (
|
||||
f"версии разъехались на {name}: periphery {d.get('version')}, "
|
||||
f"core {d.get('core_version')} - чинится только по ssh, это к Бобру"
|
||||
)
|
||||
case k if k in FAILURE:
|
||||
what = {"ProcedureFailed": "процедура", "ActionFailed": "действие"}.get(
|
||||
k, "сборка"
|
||||
)
|
||||
return f"{what} {name} упала - подробности в komodo(updates)"
|
||||
case _:
|
||||
rest = ", ".join(
|
||||
f"{k}={v}" for k, v in d.items() if k not in {"id", "server_id"}
|
||||
)
|
||||
return f"{alert.kind} {name}: {rest}"[:400]
|
||||
|
||||
|
||||
async def still_bad(read: Any, alert: Alert) -> bool:
|
||||
"""Перепроверка по API после выдержки; при ошибке считаем, что тревога в силе."""
|
||||
try:
|
||||
match alert.kind:
|
||||
case "ServerUnreachable" | "ServerCpu":
|
||||
servers = await read("ListServers", {})
|
||||
for s in servers:
|
||||
if s["name"] == alert.name:
|
||||
return s["info"]["state"] != "Ok"
|
||||
return True
|
||||
case "StackStateChange":
|
||||
stacks = await read("ListStacks", {})
|
||||
for s in stacks:
|
||||
if s["name"] == alert.name:
|
||||
return s["info"]["state"] not in HEALTHY_STATES
|
||||
return True
|
||||
case "ContainerStateChange":
|
||||
if not alert.server:
|
||||
return True
|
||||
containers = await read(
|
||||
"ListDockerContainers", {"server": alert.server}
|
||||
)
|
||||
for c in containers:
|
||||
if c["name"] == alert.name:
|
||||
return str(c.get("state", "")).lower() not in HEALTHY_STATES
|
||||
return True
|
||||
case _:
|
||||
return True
|
||||
except Exception: # noqa: BLE001 - недоступный Komodo сам по себе тревога
|
||||
return True
|
||||
File diff suppressed because it is too large.
Load diff
@@ -1,642 +0,0 @@
|
||||
"""Сторож собственных прогонов: журнал `job_runs` наконец кто-то читает.
|
||||
|
||||
Планировщик gateway пишет строку на каждый прогон джоба (`job_runs`: имя,
|
||||
статус, хвост трейсбека в `error`). Запись была всегда, читателя не было
|
||||
ни одного: канал к соседнему агенту лежал 38 часов подряд, планировщик
|
||||
честно записал это 231 раз, и до человека не доехало ничего. Этот модуль -
|
||||
вторая половина прибора: показание из таблицы превращается в тревогу.
|
||||
|
||||
Что здесь считается показанием:
|
||||
|
||||
- тревога берётся только с ХВОСТА: три и более `failed` подряд, считая от
|
||||
последнего прогона джоба. Одиночный упавший прогон - сетевой чих, а не
|
||||
болезнь, и будить на него человека значит выучить его не смотреть;
|
||||
- окно счёта - неделя, а не сутки: иначе суточный джоб не наберёт трёх
|
||||
падений подряд никогда, и `отметка`, `закрытие`, `голосовой`, `память`
|
||||
не охранялись бы вовсе;
|
||||
- отсутствие записей - тоже показание. Джоб с регулярным кроном, у которого
|
||||
последний прогон старше `FACTOR` его периодов, «не запускался» - это
|
||||
отдельная тревога, не «лежит». Период выводится из крона тем же
|
||||
`every_from_cron`, что у сторожа соседа, и расписание, которое не
|
||||
сводится к «раз в N часов», в давности не участвует и называется в логе
|
||||
неохраняемым: подставить ему число значило бы соврать. Джобы без крона
|
||||
(вебхуки, события) давностью не меряются вовсе, а джоб, которого в
|
||||
журнале нет ни разу, молча ждёт своей первой записи;
|
||||
- пустая выдача - это показание о запросе, а не о здоровье джобов. Ноль
|
||||
строк за сутки (кроме своих) означает, что планировщик вообще не
|
||||
работал, и это отдельная тревога с отдельным текстом, а не тишина;
|
||||
- упавший запрос к БД - не показание вовсе: решает джоб, здесь такого
|
||||
входа просто нет.
|
||||
|
||||
Свои собственные прогоны из счёта выкинуты (`me`): джоб, который лежит,
|
||||
о себе не доложит - наблюдатель внутри объекта не сообщает о смерти
|
||||
объекта. Это дыра прибора, и она названа в README, а не заклеена.
|
||||
|
||||
Текст тревоги проходит `mask`: из `error` берётся первая строка, режется
|
||||
по длине и чистится - общим `redact` gateway плюс два своих правила на то,
|
||||
что `redact` по конструкции не ловит внутри строки (`ИМЯ=значение` не с
|
||||
начала строки и хвост запроса у URL). Тревога уезжает в чат к диспетчеру,
|
||||
логи гейтвея видны в чатах - секрету тут негде быть.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import itertools
|
||||
import json
|
||||
import re
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from pathlib import Path # noqa: TC003 - в аннотации dataclass
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from beaver_gateway.jobs.scheduler import next_run
|
||||
from beaver_gateway.security.redact import MASK, is_secret_name, redact
|
||||
|
||||
from beaver_agent.hands.heartbeat import every_from_cron
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from collections.abc import Mapping, Sequence
|
||||
from datetime import tzinfo
|
||||
|
||||
__all__ = [
|
||||
"DAY",
|
||||
"ERROR_CHARS",
|
||||
"FACTOR",
|
||||
"FAILED",
|
||||
"FORGET",
|
||||
"MAX_LINES",
|
||||
"REPEAT",
|
||||
"STREAK",
|
||||
"WINDOW",
|
||||
"Clear",
|
||||
"Quiet",
|
||||
"Report",
|
||||
"Resumed",
|
||||
"Run",
|
||||
"Runs",
|
||||
"Streak",
|
||||
"alarm_text",
|
||||
"awake",
|
||||
"clear_text",
|
||||
"empty_text",
|
||||
"first_line",
|
||||
"look",
|
||||
"mask",
|
||||
"quiet_text",
|
||||
"streak",
|
||||
]
|
||||
|
||||
WINDOW = timedelta(days=7)
|
||||
"""Окно журнала: неделя. Суточный джоб набирает в нём три падения подряд за
|
||||
трое суток, недельный (`память`) - нет: у него три падения это три недели,
|
||||
и его охраняет давность, а не серия."""
|
||||
DAY = timedelta(hours=24)
|
||||
"""Окно тревоги о пустом журнале: сутки без единого чужого прогона."""
|
||||
FACTOR = 2
|
||||
"""Давность = столько периодов джоба без записи. Два - это «пропущено два
|
||||
срабатывания подряд»: один пропуск случается честно (передеплой пришёлся на
|
||||
минуту крона, а догонять пропущенное планировщик не умеет), два подряд -
|
||||
уже не случайность."""
|
||||
GRAIN = timedelta(minutes=1)
|
||||
"""Шаг, в котором период крона должен сводиться к целому: крон минутный."""
|
||||
LAG = timedelta(minutes=10)
|
||||
"""Запись в журнал ложится по КОНЦУ прогона: срабатывание моложе этого
|
||||
могло ещё не дописаться, и пропуском его не считаем."""
|
||||
STREAK = 3
|
||||
"""Сколько `failed` подряд считаем «джоб лежит»."""
|
||||
REPEAT = timedelta(hours=24)
|
||||
"""Чаще этого об одном и том же джобе не говорим."""
|
||||
FORGET = timedelta(days=7)
|
||||
"""Джоб, о котором тревожились, исчез из окна насовсем - забываем его молча:
|
||||
починки мы не видели, врать «отбой» не о чем."""
|
||||
ERROR_CHARS = 160
|
||||
"""Сколько букв первой строки ошибки уезжает человеку."""
|
||||
MAX_LINES = 10
|
||||
"""Сколько джобов перечисляем в одной тревоге: сразу всё не читают."""
|
||||
FAILED = "failed"
|
||||
_DAYS_FROM = timedelta(hours=48)
|
||||
STATE_VERSION = 1
|
||||
|
||||
_PAIR = re.compile(r"(?=([A-Za-z][\w.-]{2,})\s*([:=])\s*([^\s,;)\]}\"']{6,}))")
|
||||
"""`ИМЯ=значение` где угодно в строке: общий `redact` ловит такие пары только
|
||||
с начала строки, а трейсбек кладёт их в середину. Просмотр нулевой длины -
|
||||
чтобы `RuntimeError: MSOS_MCP=…` не съедало секрет первой же парой: обычный
|
||||
`sub` откусил бы `RuntimeError:` вместе со значением и до вложенной пары
|
||||
не дошёл."""
|
||||
_QUERY = re.compile(r"(https?://[^\s?#]+)\?[^\s#]*")
|
||||
"""Хвост запроса у URL сносим целиком: имя параметра с ключом может быть любым."""
|
||||
|
||||
|
||||
def _iso(when: datetime | None) -> str | None:
|
||||
if when is None:
|
||||
return None
|
||||
return when.astimezone(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
|
||||
|
||||
|
||||
def _parse_iso(raw: str | None) -> datetime | None:
|
||||
if not raw:
|
||||
return None
|
||||
try:
|
||||
when = datetime.fromisoformat(raw)
|
||||
except ValueError:
|
||||
return None
|
||||
return when if when.tzinfo else when.replace(tzinfo=UTC)
|
||||
|
||||
|
||||
def _plural(count: int, forms: tuple[str, str, str]) -> str:
|
||||
if count % 10 == 1 and count % 100 != 11:
|
||||
return forms[0]
|
||||
if count % 10 in (2, 3, 4) and count % 100 not in (12, 13, 14):
|
||||
return forms[1]
|
||||
return forms[2]
|
||||
|
||||
|
||||
def _age(delta: timedelta) -> str:
|
||||
"""Возраст человеку: «4 часа», «45 минут», «15 суток». Секунды не нужны."""
|
||||
minutes = max(int(delta.total_seconds()) // 60, 0)
|
||||
if minutes < 60:
|
||||
return f"{minutes} {_plural(minutes, ('минуту', 'минуты', 'минут'))}"
|
||||
hours = minutes // 60
|
||||
if delta >= _DAYS_FROM:
|
||||
days = hours // 24
|
||||
return f"{days} {_plural(days, ('сутки', 'суток', 'суток'))}"
|
||||
return f"{hours} {_plural(hours, ('час', 'часа', 'часов'))}"
|
||||
|
||||
|
||||
def _period(delta: timedelta) -> str:
|
||||
"""Период крона: «10 минут», «24 часа», «7 суток» - без округления."""
|
||||
minutes = int(delta.total_seconds()) // 60
|
||||
if minutes % (24 * 60) == 0 and delta >= _DAYS_FROM:
|
||||
days = minutes // (24 * 60)
|
||||
return f"{days} {_plural(days, ('сутки', 'суток', 'суток'))}"
|
||||
if minutes % 60 == 0:
|
||||
hours = minutes // 60
|
||||
return f"{hours} {_plural(hours, ('час', 'часа', 'часов'))}"
|
||||
return f"{minutes} {_plural(minutes, ('минута', 'минуты', 'минут'))}"
|
||||
|
||||
|
||||
def _mask_pairs(text: str) -> str:
|
||||
out: list[str] = []
|
||||
pos = 0
|
||||
for match in _PAIR.finditer(text):
|
||||
if match.start(3) < pos or not is_secret_name(match[1]):
|
||||
continue
|
||||
out.append(text[pos : match.start(3)])
|
||||
out.append(MASK)
|
||||
pos = match.end(3)
|
||||
out.append(text[pos:])
|
||||
return "".join(out)
|
||||
|
||||
|
||||
def mask(text: str) -> str:
|
||||
"""Убрать из строки всё, что похоже на секрет, прежде чем её показывать."""
|
||||
return _QUERY.sub(r"\1?" + MASK, _mask_pairs(redact(text)))
|
||||
|
||||
|
||||
def first_line(error: str | None) -> str:
|
||||
"""Первая строка ошибки - чистая и короткая. Трейсбек человеку не нужен."""
|
||||
for line in mask(error or "").splitlines():
|
||||
head = line.strip()
|
||||
if not head:
|
||||
continue
|
||||
if len(head) > ERROR_CHARS:
|
||||
head = head[: ERROR_CHARS - 1].rstrip() + "…"
|
||||
return head
|
||||
return "без текста ошибки"
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Run:
|
||||
"""Одна строка журнала: ровно то, на что мы смотрим, без ORM."""
|
||||
|
||||
id: int
|
||||
job: str
|
||||
status: str
|
||||
started_at: datetime
|
||||
error: str | None = None
|
||||
|
||||
@property
|
||||
def failed(self) -> bool:
|
||||
return self.status == FAILED
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Streak:
|
||||
"""Хвост подряд упавших прогонов одного джоба."""
|
||||
|
||||
job: str
|
||||
count: int
|
||||
since: datetime
|
||||
"""Начало серии - первое падение из тех, что видно в окне."""
|
||||
age: timedelta
|
||||
error: str
|
||||
capped: bool
|
||||
"""Серия упёрлась в край окна: падений было НЕ МЕНЬШЕ `count`, а сколько
|
||||
на самом деле - за неделей не видно, и врать точным числом нельзя."""
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Quiet:
|
||||
"""Джоб с кроном, который перестал запускаться."""
|
||||
|
||||
job: str
|
||||
age: timedelta
|
||||
"""Сколько прошло с начала последнего прогона - любого, хоть упавшего."""
|
||||
period: timedelta
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Resumed:
|
||||
"""Джоб, о молчании которого говорили, снова запустился."""
|
||||
|
||||
job: str
|
||||
status: str
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Clear:
|
||||
"""Джоб, о котором мы тревожились, больше не лежит."""
|
||||
|
||||
job: str
|
||||
status: str
|
||||
"""Статус последнего прогона."""
|
||||
count: int
|
||||
"""Сколько подряд упавших осталось в хвосте: 0 - чисто."""
|
||||
|
||||
|
||||
@dataclass(slots=True)
|
||||
class Runs:
|
||||
"""Состояние между прогонами: кому и когда уже сказали."""
|
||||
|
||||
path: Path
|
||||
alerted: dict[str, datetime] = field(default_factory=dict)
|
||||
"""Джоб → когда о нём ушла тревога. Он же признак «сейчас в тревоге»."""
|
||||
quiet: dict[str, datetime] = field(default_factory=dict)
|
||||
"""То же для «не запускался»: отдельно, у тревог разные отбои."""
|
||||
empty_alerted: datetime | None = None
|
||||
|
||||
@classmethod
|
||||
def load(cls, path: Path) -> Runs:
|
||||
try:
|
||||
raw = json.loads(path.read_text(encoding="utf-8"))
|
||||
except (OSError, ValueError):
|
||||
return cls(path=path)
|
||||
if raw.get("version") != STATE_VERSION:
|
||||
return cls(path=path)
|
||||
return cls(
|
||||
path=path,
|
||||
alerted=_stamps(raw.get("alerted")),
|
||||
quiet=_stamps(raw.get("quiet")),
|
||||
empty_alerted=_parse_iso(raw.get("empty_alerted")),
|
||||
)
|
||||
|
||||
def save(self) -> None:
|
||||
body = {
|
||||
"version": STATE_VERSION,
|
||||
"alerted": {job: _iso(when) for job, when in sorted(self.alerted.items())},
|
||||
"quiet": {job: _iso(when) for job, when in sorted(self.quiet.items())},
|
||||
"empty_alerted": _iso(self.empty_alerted),
|
||||
}
|
||||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||||
tmp = self.path.with_suffix(".tmp")
|
||||
tmp.write_text(json.dumps(body, ensure_ascii=False, indent=1), encoding="utf-8")
|
||||
tmp.replace(self.path)
|
||||
|
||||
|
||||
def _stamps(raw: dict[str, str] | None) -> dict[str, datetime]:
|
||||
out = {}
|
||||
for job, when in (raw or {}).items():
|
||||
parsed = _parse_iso(str(when))
|
||||
if parsed is not None:
|
||||
out[str(job)] = parsed
|
||||
return out
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Report:
|
||||
"""Что решил один прогон сторожа журнала."""
|
||||
|
||||
alarms: tuple[Streak, ...]
|
||||
clears: tuple[Clear, ...]
|
||||
empty: bool
|
||||
"""Прогонов за сутки не было вовсе - тревога о планировщике, не о джобе."""
|
||||
seen: int
|
||||
"""Сколько чужих прогонов было в окне."""
|
||||
mine: int
|
||||
"""Сколько своих - их в счёт не берём, но в тексте называем."""
|
||||
note: str
|
||||
quiet: tuple[Quiet, ...] = ()
|
||||
resumed: tuple[Resumed, ...] = ()
|
||||
unguarded: tuple[str, ...] = ()
|
||||
"""Джобы с кроном, у которого нет регулярного периода: давностью не меряем."""
|
||||
|
||||
|
||||
def streak(runs: Sequence[Run], *, now: datetime) -> Streak | None:
|
||||
"""Хвост падений одного джоба, считая от последнего прогона.
|
||||
|
||||
`runs` - прогоны одного джоба, новейший первым. Серия, упёршаяся в край
|
||||
окна, помечается `capped`: её настоящую длину мы не знаем.
|
||||
"""
|
||||
failures = list(itertools.takewhile(lambda run: run.failed, runs))
|
||||
if not failures:
|
||||
return None
|
||||
oldest = failures[-1]
|
||||
return Streak(
|
||||
job=failures[0].job,
|
||||
count=len(failures),
|
||||
since=oldest.started_at,
|
||||
age=now - oldest.started_at,
|
||||
error=first_line(failures[0].error),
|
||||
capped=len(failures) == len(runs),
|
||||
)
|
||||
|
||||
|
||||
def look(
|
||||
state: Runs,
|
||||
runs: Sequence[Run],
|
||||
*,
|
||||
now: datetime,
|
||||
me: str,
|
||||
crons: Mapping[str, str] | None = None,
|
||||
latest: Mapping[str, Run] | None = None,
|
||||
tz: tzinfo = UTC,
|
||||
boot: datetime | None = None,
|
||||
) -> Report:
|
||||
"""Разобрать окно журнала и решить, о чём говорить человеку.
|
||||
|
||||
`crons` - джоб → крон, только джобы с кроном; `latest` - последний прогон
|
||||
каждого джоба за ВСЮ историю журнала, а не за окно; `boot` - старт
|
||||
процесса. Без `crons` давность не проверяется вовсе.
|
||||
|
||||
Состояние здесь только чистится от забытых джобов; отметки «сказали» и
|
||||
«сказали про пустоту» ставит джоб - и только когда тревога действительно
|
||||
ушла: несостоявшаяся доставка не должна заглушать следующий прогон.
|
||||
"""
|
||||
mine = [run for run in runs if run.job == me]
|
||||
others = sorted(
|
||||
(run for run in runs if run.job != me), key=lambda run: run.id, reverse=True
|
||||
)
|
||||
if not any(now - run.started_at < DAY for run in others):
|
||||
quiet = state.empty_alerted is not None and now - state.empty_alerted < REPEAT
|
||||
return Report(
|
||||
alarms=(),
|
||||
clears=(),
|
||||
empty=not quiet,
|
||||
seen=len(others),
|
||||
mine=len(mine),
|
||||
note=(
|
||||
f"чужих прогонов за сутки нет вовсе (своих {len(mine)})"
|
||||
+ ("; о пустоте уже говорили меньше суток назад" if quiet else "")
|
||||
),
|
||||
)
|
||||
|
||||
by_job: dict[str, list[Run]] = {}
|
||||
for run in others:
|
||||
by_job.setdefault(run.job, []).append(run)
|
||||
|
||||
alarms: list[Streak] = []
|
||||
clears: list[Clear] = []
|
||||
held: list[str] = []
|
||||
for job, rows in by_job.items():
|
||||
tail = streak(rows, now=now)
|
||||
if tail is not None and tail.count >= STREAK:
|
||||
told = state.alerted.get(job)
|
||||
if told is None or now - told >= REPEAT:
|
||||
alarms.append(tail)
|
||||
else:
|
||||
held.append(job)
|
||||
elif job in state.alerted:
|
||||
clears.append(
|
||||
Clear(
|
||||
job=job,
|
||||
status=rows[0].status,
|
||||
count=0 if tail is None else tail.count,
|
||||
)
|
||||
)
|
||||
|
||||
forgotten = [
|
||||
job
|
||||
for job, told in state.alerted.items()
|
||||
if job not in by_job and now - told >= FORGET
|
||||
]
|
||||
for job in forgotten:
|
||||
del state.alerted[job]
|
||||
|
||||
note = (
|
||||
f"прогонов за неделю {len(others)} по {len(by_job)} джобам (своих {len(mine)})"
|
||||
)
|
||||
if alarms:
|
||||
note += "; лежат: " + ", ".join(sorted(tail.job for tail in alarms))
|
||||
if held:
|
||||
note += "; уже говорили меньше суток назад: " + ", ".join(sorted(held))
|
||||
if clears:
|
||||
note += "; починились: " + ", ".join(sorted(clear.job for clear in clears))
|
||||
if forgotten:
|
||||
note += "; забыты (пропали из окна): " + ", ".join(sorted(forgotten))
|
||||
|
||||
silence = _silence(
|
||||
state,
|
||||
mine,
|
||||
now=now,
|
||||
me=me,
|
||||
crons=crons or {},
|
||||
latest=latest or {},
|
||||
tz=tz,
|
||||
boot=boot,
|
||||
)
|
||||
|
||||
return Report(
|
||||
alarms=tuple(sorted(alarms, key=lambda tail: tail.count, reverse=True)),
|
||||
clears=tuple(sorted(clears, key=lambda clear: clear.job)),
|
||||
empty=False,
|
||||
seen=len(others),
|
||||
mine=len(mine),
|
||||
note=note + silence.note,
|
||||
quiet=silence.quiet,
|
||||
resumed=silence.resumed,
|
||||
unguarded=silence.unguarded,
|
||||
)
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class _Silence:
|
||||
quiet: tuple[Quiet, ...]
|
||||
resumed: tuple[Resumed, ...]
|
||||
unguarded: tuple[str, ...]
|
||||
note: str
|
||||
|
||||
|
||||
def awake(
|
||||
mine: Sequence[Run], *, now: datetime, step: timedelta, boot: datetime | None
|
||||
) -> datetime:
|
||||
"""С какого момента планировщик заведомо крутил некритичные джобы.
|
||||
|
||||
Показание - собственные прогоны сторожа: он сам некритичный, и когда
|
||||
гейтвей лежит или бюджет зажат (`throttled` откладывает некритичный крон
|
||||
без записи в журнал), его прогонов нет так же, как и чужих. Цепочка своих
|
||||
прогонов без разрыва длиннее `step`, считая от сейчас, плюс старт
|
||||
процесса - это время, за которое чужой пропуск действительно пропуск,
|
||||
а не общий простой.
|
||||
"""
|
||||
anchor = now
|
||||
for run in sorted(mine, key=lambda run: run.started_at, reverse=True):
|
||||
if anchor - run.started_at > step:
|
||||
break
|
||||
anchor = min(anchor, run.started_at)
|
||||
return anchor if boot is None else max(anchor, boot)
|
||||
|
||||
|
||||
def _silence(
|
||||
state: Runs,
|
||||
mine: Sequence[Run],
|
||||
*,
|
||||
now: datetime,
|
||||
me: str,
|
||||
crons: Mapping[str, str],
|
||||
latest: Mapping[str, Run],
|
||||
tz: tzinfo,
|
||||
boot: datetime | None,
|
||||
) -> _Silence:
|
||||
"""Давность: какие джобы с кроном перестали запускаться."""
|
||||
own = every_from_cron(crons.get(me), tz, now=now, grain=GRAIN)
|
||||
guarded: dict[str, timedelta] = {}
|
||||
unguarded: list[str] = []
|
||||
for job, cron in crons.items():
|
||||
if job == me:
|
||||
continue
|
||||
period = every_from_cron(cron, tz, now=now, grain=GRAIN)
|
||||
if period is None:
|
||||
unguarded.append(job)
|
||||
else:
|
||||
guarded[job] = period
|
||||
|
||||
note = ""
|
||||
if unguarded:
|
||||
note += "; давностью не охраняются (крон без регулярного периода): " + (
|
||||
", ".join(sorted(unguarded))
|
||||
)
|
||||
dropped = [job for job in state.quiet if job not in guarded]
|
||||
for job in dropped:
|
||||
del state.quiet[job]
|
||||
if dropped:
|
||||
note += "; сняты с давности (нет в расписании): " + ", ".join(sorted(dropped))
|
||||
if not guarded:
|
||||
return _Silence((), (), tuple(sorted(unguarded)), note)
|
||||
if own is None:
|
||||
# Свой период не выведен - нет и опоры, когда планировщик заведомо
|
||||
# работал. Любое число тут было бы выдумано.
|
||||
note += "; свой крон без регулярного периода - давность не проверяется"
|
||||
return _Silence((), (), tuple(sorted(unguarded)), note)
|
||||
|
||||
since = awake(mine, now=now, step=own * FACTOR, boot=boot)
|
||||
quiet: list[Quiet] = []
|
||||
resumed: list[Resumed] = []
|
||||
held: list[str] = []
|
||||
fresh: list[str] = []
|
||||
for job, period in guarded.items():
|
||||
last = latest.get(job)
|
||||
if last is None:
|
||||
fresh.append(job)
|
||||
continue
|
||||
age = now - last.started_at
|
||||
# Порог не тоньше собственного: чаще раза в час сторож не смотрит, и
|
||||
# пропуск короче двух своих периодов неотличим от его же слепоты.
|
||||
overdue = (
|
||||
age > max(period, own) * FACTOR
|
||||
and next_run(crons[job], tz, max(last.started_at, since)) <= now - LAG
|
||||
)
|
||||
told = state.quiet.get(job)
|
||||
if overdue:
|
||||
if told is None or now - told >= REPEAT:
|
||||
quiet.append(Quiet(job=job, age=age, period=period))
|
||||
else:
|
||||
held.append(job)
|
||||
elif told is not None and last.started_at > told:
|
||||
resumed.append(Resumed(job=job, status=last.status))
|
||||
|
||||
if fresh:
|
||||
note += "; ещё ни разу не запускались: " + ", ".join(sorted(fresh))
|
||||
if quiet:
|
||||
note += "; не запускаются: " + ", ".join(sorted(q.job for q in quiet))
|
||||
if held:
|
||||
note += "; о молчании уже говорили меньше суток назад: " + ", ".join(
|
||||
sorted(held)
|
||||
)
|
||||
if resumed:
|
||||
note += "; снова запускаются: " + ", ".join(sorted(r.job for r in resumed))
|
||||
return _Silence(
|
||||
quiet=tuple(sorted(quiet, key=lambda q: q.age, reverse=True)),
|
||||
resumed=tuple(sorted(resumed, key=lambda r: r.job)),
|
||||
unguarded=tuple(sorted(unguarded)),
|
||||
note=note,
|
||||
)
|
||||
|
||||
|
||||
def streak_line(tail: Streak) -> str:
|
||||
"""«джоб `вайбграм` лежит 4 часа, 24 прогона подряд с 12.09 18:00 UTC: …»."""
|
||||
runs = f"{tail.count} {_plural(tail.count, ('прогон', 'прогона', 'прогонов'))}"
|
||||
return (
|
||||
f"джоб `{tail.job}` лежит {_age(tail.age)}"
|
||||
f"{' и дольше' if tail.capped else ''}, {runs} подряд с "
|
||||
f"{tail.since.astimezone(UTC).strftime('%d.%m %H:%M UTC')}"
|
||||
+ (" (это всё окно недели, серия началась раньше)" if tail.capped else "")
|
||||
+ f": {tail.error}"
|
||||
)
|
||||
|
||||
|
||||
def alarm_text(report: Report) -> str:
|
||||
"""Тревога человеку: что лежит, сколько и с какой ошибкой."""
|
||||
lines = [f"- {streak_line(tail)}" for tail in report.alarms[:MAX_LINES]]
|
||||
rest = len(report.alarms) - len(lines)
|
||||
if rest > 0:
|
||||
lines.append(f"- и ещё {rest} {_plural(rest, ('джоб', 'джоба', 'джобов'))}")
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
def quiet_line(quiet: Quiet) -> str:
|
||||
"""«джоб `закрытие` не запускался 50 часов при периоде 24 часа»."""
|
||||
return (
|
||||
f"джоб `{quiet.job}` не запускался {_age(quiet.age)} "
|
||||
f"при периоде {_period(quiet.period)}"
|
||||
)
|
||||
|
||||
|
||||
def quiet_text(report: Report) -> str:
|
||||
"""Тревога о молчании: какие джобы с кроном перестали запускаться."""
|
||||
lines = [f"- {quiet_line(quiet)}" for quiet in report.quiet[:MAX_LINES]]
|
||||
rest = len(report.quiet) - len(lines)
|
||||
if rest > 0:
|
||||
lines.append(f"- и ещё {rest} {_plural(rest, ('джоб', 'джоба', 'джобов'))}")
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
def resumed_line(resumed: Resumed) -> str:
|
||||
return f"отбой: джоб `{resumed.job}` снова запускается ({resumed.status})"
|
||||
|
||||
|
||||
def clear_line(clear: Clear) -> str:
|
||||
if clear.count == 0:
|
||||
return f"отбой: джоб `{clear.job}` снова проходит ({clear.status})"
|
||||
return (
|
||||
f"отбой: джоб `{clear.job}` больше не лежит подряд "
|
||||
f"(упавших в хвосте {clear.count}, порог {STREAK})"
|
||||
)
|
||||
|
||||
|
||||
def clear_text(report: Report) -> str:
|
||||
lines = [clear_line(clear) for clear in report.clears]
|
||||
lines += [resumed_line(resumed) for resumed in report.resumed]
|
||||
return "\n".join(f"- {line}" for line in lines)
|
||||
|
||||
|
||||
def empty_text(report: Report) -> str:
|
||||
"""Отдельная тревога: за сутки не отработал вообще никто."""
|
||||
return (
|
||||
f"За последние сутки в журнале прогонов (`job_runs`) нет ни одной записи, "
|
||||
f"кроме моих собственных (их {report.mine}): не отработал ни один джоб. "
|
||||
"Это показание о планировщике, а не о каком-то одном джобе. Смотреть "
|
||||
"стоит три вещи: поднялся ли планировщик вообще (в логе gateway "
|
||||
"`scheduler: no postgres driver - cron and webhooks are off`), живы ли "
|
||||
"кроны в pgqueuer, и не заведена ли база заново - на пустой базе эта же "
|
||||
"тревога выглядит так же."
|
||||
)
|
||||
@@ -1,454 +0,0 @@
|
||||
"""вайбграм - комната агентов на хабе, как python_tool.
|
||||
|
||||
Хаб - `VIBEGRAM_HUB`, протокол - REST с bearer-токеном агента
|
||||
(выдан при `vibegram join`, лежит в env gateway и в контекст модели не
|
||||
попадает). Диспетчер сидит в комнате сам (внутренний контур с соседями),
|
||||
но через перечислимые действия: прочитать новое, написать, кто в комнате,
|
||||
что занято, план, claim/release, карточка. Один и тот же клиент кормит
|
||||
крон-проверку (`pending`) и тулзу (`vibegram`).
|
||||
|
||||
`/api/pending` - курсор на стороне хаба: прочитанное второй раз не
|
||||
приходит. Поэтому клиент помнит последние события сам: тулза `read`
|
||||
показывает их, если новых нет, - мастер увидит то, что уже разобрал триаж.
|
||||
|
||||
Там, где нужен не «что нового», а «последние N строк комнаты» (сторож) или
|
||||
«всё после события #N» (`read since=` / `read last=` у мастера), курсор не
|
||||
годится в принципе: `history` читает историю через `/api/state`, не трогая
|
||||
курсор и ничего не вычёркивая.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
from collections import deque
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import UTC, datetime
|
||||
from pathlib import Path # noqa: TC003 - в аннотации dataclass
|
||||
from typing import Any, Literal
|
||||
from urllib.parse import quote
|
||||
from zoneinfo import ZoneInfo
|
||||
|
||||
import aiohttp
|
||||
|
||||
__all__ = ["Action", "Event", "Vibegram", "Window"]
|
||||
|
||||
Action = Literal["read", "send", "who", "work", "plan", "claim", "release", "card"]
|
||||
|
||||
USER_AGENT = "beaver-agent/0.1 (+vibegram)"
|
||||
REMEMBER = 40
|
||||
PAGE = 200
|
||||
"""Сколько событий комнаты хаб отдаёт за одну страницу `/api/state`: его
|
||||
потолок, а не наша просьба - `limit` там не слушают."""
|
||||
PAGES = 25
|
||||
"""Потолок дочитывания истории. Упёрлись - окно объявляем неполным, а не
|
||||
выдаём за хвост то, что оказалось под рукой."""
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Event:
|
||||
id: int
|
||||
nick: str
|
||||
kind: str
|
||||
text: str
|
||||
at: str
|
||||
|
||||
def line(self) -> str:
|
||||
return f"[{self.at}] {self.text}"
|
||||
|
||||
def tagged(self) -> str:
|
||||
return f"#{self.id} {self.line()}"
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Window:
|
||||
"""Хвост комнаты: последние сообщения и честный признак полноты."""
|
||||
|
||||
events: list[Event]
|
||||
full: bool
|
||||
"""История дочитана до конца: в `events` действительно ПОСЛЕДНИЕ сообщения.
|
||||
Ложь здесь - это «в окне никого» там, где окно просто не дочитано."""
|
||||
|
||||
|
||||
@dataclass(slots=True)
|
||||
class Vibegram:
|
||||
hub: str
|
||||
token: str
|
||||
nick: str
|
||||
repo: Path | None = None
|
||||
tz: str = "UTC"
|
||||
"""Время в строках событий - в этой зоне (хаб отдаёт UTC)."""
|
||||
timeout: float = 15.0
|
||||
max_chars: int = 8_000
|
||||
_cursor: int = 0
|
||||
_recent: deque[Event] = field(default_factory=lambda: deque(maxlen=REMEMBER))
|
||||
|
||||
async def vibegram(
|
||||
self,
|
||||
action: Action,
|
||||
*,
|
||||
text: str | None = None,
|
||||
paths: list[str] | None = None,
|
||||
note: str | None = None,
|
||||
about: str | None = None,
|
||||
skills: list[str] | None = None,
|
||||
since: int | None = None,
|
||||
last: int | None = None,
|
||||
) -> str:
|
||||
"""Вайбграм - комната агентов (чужие клоды и ты) вокруг общей репы.
|
||||
|
||||
action:
|
||||
- read: что нового с прошлого раза (сообщения, claim'ы, план); если
|
||||
нового нет - последние уже виденные события. Курсор общий с
|
||||
крон-триажем: прочитанное здесь второй раз не придёт.
|
||||
- read since=N / read last=N: история комнаты - всё после события #N
|
||||
или последние N сообщений. Ничего не съедает, спрашивать можно
|
||||
сколько угодно раз. Вывод «сосед молчит» брать только отсюда: пустой
|
||||
read - это «крон уже выгреб», а не «никто не ответил».
|
||||
- send: написать в комнату (text). Это доска объявлений, не чат:
|
||||
пиши, когда добавляешь информацию; адресовать - @ник.
|
||||
- who: кто в комнате, что умеет, что держит.
|
||||
- work: свободные пункты плана, занятые файлы, кто что делает.
|
||||
- plan: общий план комнаты.
|
||||
- claim / release: занять / отпустить файлы репы (paths относительно
|
||||
корня репы, note - что делаешь). Перед правкой - claim, после - release.
|
||||
- card: рассказать о себе (about, skills).
|
||||
|
||||
Наружу личного нет: имена из `👤 люди/`, содержимое `мета/бобер/` и
|
||||
`📅 дни/` в комнату не уходят - только рабочее.
|
||||
"""
|
||||
match action:
|
||||
case "read":
|
||||
return await self._read(since=since, last=last)
|
||||
case "send":
|
||||
return await self._send(_need(text, "text"))
|
||||
case "who":
|
||||
return _cards((await self._get("/api/cards"))["cards"], self.nick)
|
||||
case "work":
|
||||
return _work(await self._get("/api/work"), self.nick)
|
||||
case "plan":
|
||||
return _plan(await self._get("/api/plan"))
|
||||
case "claim":
|
||||
result = await self._post(
|
||||
"/api/claims", {"resources": _need_list(paths), "note": note}
|
||||
)
|
||||
if result.get("ok"):
|
||||
held = ", ".join(c["resource"] for c in result.get("claims", []))
|
||||
return f"занято: {held}"
|
||||
return "\n".join(
|
||||
f"{c['resource']} держит {c['heldBy']}"
|
||||
+ (f" ({c['note']})" if c.get("note") else "")
|
||||
+ " - напиши ему через send, не обходи"
|
||||
for c in result.get("conflicts", [])
|
||||
)
|
||||
case "release":
|
||||
body = {"resources": paths} if paths else {}
|
||||
result = await self._post("/api/claims/release", body)
|
||||
released = result.get("released") or []
|
||||
return (
|
||||
"отпущено: " + ", ".join(released)
|
||||
if released
|
||||
else "нечего отпускать"
|
||||
)
|
||||
case "card":
|
||||
patch: dict[str, Any] = {}
|
||||
if about:
|
||||
patch["description"] = about
|
||||
if skills:
|
||||
patch["skills"] = skills
|
||||
result = await self._post("/api/card", patch)
|
||||
return _cards([result["card"]], self.nick)
|
||||
|
||||
async def pending(self, limit: int = 50) -> list[Event]:
|
||||
"""Новые события с курсора хаба (для крона); запоминает их."""
|
||||
data = await self._get(f"/api/pending?limit={limit}")
|
||||
events = [
|
||||
e
|
||||
for e in (_event(raw, self.tz) for raw in data.get("events", []))
|
||||
if e is not None
|
||||
]
|
||||
fresh = [e for e in events if e.id > self._cursor]
|
||||
for e in fresh:
|
||||
self._recent.append(e)
|
||||
self._cursor = max(self._cursor, e.id)
|
||||
ack = data.get("planAckNeeded")
|
||||
if ack is not None:
|
||||
fresh.append(
|
||||
Event(
|
||||
id=self._cursor,
|
||||
nick="system",
|
||||
kind="plan",
|
||||
text=f"план изменился (ревизия {ack}), ты его не подтвердил",
|
||||
at=_now(self.tz),
|
||||
)
|
||||
)
|
||||
return fresh
|
||||
|
||||
async def window(self, limit: int, *, pages: int = PAGES) -> Window:
|
||||
"""Последние `limit` СООБЩЕНИЙ этой комнаты: хвост истории, не курсор.
|
||||
|
||||
`pending` для окна не годится вовсе: это курсор на стороне хаба, он
|
||||
отдаёт только то, чего мы ещё не видели, и ту же строку второй раз не
|
||||
пришлёт - следующий прогон увидит пустое окно на живой комнате.
|
||||
|
||||
Хвост берём из `/api/state?view=…`: события там уже отфильтрованы по
|
||||
комнате (ключ - `viewToken` этой комнаты, id у хаба сквозные по всем
|
||||
комнатам), но страницы идут ВПЕРЁД, по `PAGE` штук от `after=<id>`, -
|
||||
назад хаб не пагинирует и `limit` не слушает. Поэтому проходим историю
|
||||
от начала, держа в руке только последние `limit` сообщений. `join` и
|
||||
`leave` в окно не берём: это бухгалтерия хаба, а не строки соседа.
|
||||
|
||||
`viewToken` спрашиваем каждый раз заново: протухший в кэше ключ - ровно
|
||||
то тихое враньё, ради которого окно и переписано.
|
||||
"""
|
||||
return await self.history(limit=limit, pages=pages)
|
||||
|
||||
async def history(
|
||||
self, *, after: int = 0, limit: int | None = None, pages: int = PAGES
|
||||
) -> Window:
|
||||
"""Сообщения комнаты после события `after`, хвостом не длиннее `limit`.
|
||||
|
||||
Непотребляющий проход по `/api/state`: курсор `/api/pending` остаётся
|
||||
там, где стоял, поэтому спрашивать можно сколько угодно раз.
|
||||
`limit=None` - всё, что нашлось после `after`.
|
||||
"""
|
||||
view = quote(str((await self._get("/api/room"))["room"]["viewToken"]))
|
||||
tail: deque[Event] = deque(maxlen=limit)
|
||||
full = False
|
||||
for _ in range(pages):
|
||||
page = await self._get(f"/api/state?view={view}&after={after}")
|
||||
raw = page.get("events") or []
|
||||
for item in raw:
|
||||
if item.get("kind") != "message":
|
||||
continue
|
||||
event = _event(item, self.tz)
|
||||
if event is not None:
|
||||
tail.append(event)
|
||||
top = max((int(item.get("id") or 0) for item in raw), default=after)
|
||||
if len(raw) < PAGE or top <= after:
|
||||
full = True
|
||||
break
|
||||
after = top
|
||||
return Window(events=list(tail), full=full)
|
||||
|
||||
async def say(self, text: str) -> None:
|
||||
"""Написать в комнату; сбой хаба - исключение, а не строка.
|
||||
|
||||
Тулза мастера мягче (`_send` превращает rate limit в текст), но
|
||||
механизмам нужен отказ, который видно: сторож по нему отличает
|
||||
мёртвый канал от мёртвого соседа.
|
||||
"""
|
||||
await self._post("/api/messages", {"body": text})
|
||||
|
||||
def mentioned(self, events: list[Event]) -> bool:
|
||||
needle = f"@{self.nick}".lower()
|
||||
return any(needle in e.text.lower() for e in events)
|
||||
|
||||
async def _read(self, *, since: int | None = None, last: int | None = None) -> str:
|
||||
if since is not None or last is not None:
|
||||
return await self._history(since=since, last=last)
|
||||
fresh = await self.pending()
|
||||
if fresh:
|
||||
return self._clip("\n".join(e.tagged() for e in fresh))
|
||||
if self._recent:
|
||||
tail = "\n".join(e.tagged() for e in list(self._recent)[-10:])
|
||||
return f"нового нет; последнее, что было:\n{tail}"
|
||||
return "нового нет"
|
||||
|
||||
async def _history(self, *, since: int | None, last: int | None) -> str:
|
||||
if last is not None and last <= 0:
|
||||
msg = "last - сколько последних сообщений показать, нужно число больше нуля"
|
||||
raise ValueError(msg)
|
||||
after = max(since or 0, 0)
|
||||
window = await self.history(after=after, limit=last)
|
||||
if not window.events:
|
||||
if not window.full:
|
||||
return f"историю после #{after} не дочитали до конца, пусто пока"
|
||||
return (
|
||||
f"после #{after} сообщений нет (история дочитана)"
|
||||
if after
|
||||
else "сообщений в комнате нет"
|
||||
)
|
||||
lines = [e.tagged() for e in window.events]
|
||||
if not window.full:
|
||||
lines.insert(0, "окно неполное: до конца истории не дочитали")
|
||||
return self._clip("\n".join(lines))
|
||||
|
||||
async def _send(self, text: str) -> str:
|
||||
try:
|
||||
await self._post("/api/messages", {"body": text})
|
||||
except HubError as exc:
|
||||
if exc.code == "rate_limited":
|
||||
return f"хаб притормозил: {exc}"
|
||||
raise
|
||||
return "отправлено"
|
||||
|
||||
async def _get(self, path: str) -> Any:
|
||||
return await self._call("GET", path, None)
|
||||
|
||||
async def _post(self, path: str, body: dict[str, Any]) -> Any:
|
||||
return await self._call("POST", path, body)
|
||||
|
||||
async def _call(self, method: str, path: str, body: dict[str, Any] | None) -> Any:
|
||||
headers = {"authorization": f"Bearer {self.token}", "user-agent": USER_AGENT}
|
||||
async with (
|
||||
aiohttp.ClientSession() as http,
|
||||
http.request(
|
||||
method,
|
||||
f"{self.hub.rstrip('/')}{path}",
|
||||
json=body,
|
||||
headers=headers,
|
||||
timeout=aiohttp.ClientTimeout(total=self.timeout),
|
||||
) as response,
|
||||
):
|
||||
raw = await response.text()
|
||||
try:
|
||||
data = json.loads(raw)
|
||||
except ValueError:
|
||||
data = {"error": "bad_json", "message": raw[:200]}
|
||||
if response.status >= 400:
|
||||
raise HubError(
|
||||
response.status,
|
||||
str(data.get("error") or "error"),
|
||||
str(data.get("message") or data.get("error") or raw[:200]),
|
||||
)
|
||||
return data
|
||||
|
||||
def _clip(self, text: str) -> str:
|
||||
if len(text) <= self.max_chars:
|
||||
return text
|
||||
return text[: self.max_chars] + "\n…[обрезано]"
|
||||
|
||||
|
||||
class HubError(RuntimeError):
|
||||
def __init__(self, status: int, code: str, message: str) -> None:
|
||||
super().__init__(f"vibegram {status} {code}: {message}")
|
||||
self.status = status
|
||||
self.code = code
|
||||
|
||||
|
||||
def _now(tz: str = "UTC") -> str:
|
||||
return datetime.now(UTC).astimezone(ZoneInfo(tz)).strftime("%m-%d %H:%M")
|
||||
|
||||
|
||||
def _when(iso: Any, tz: str = "UTC") -> str:
|
||||
try:
|
||||
when = datetime.fromisoformat(str(iso))
|
||||
except ValueError:
|
||||
return _now(tz)
|
||||
if when.tzinfo is None:
|
||||
when = when.replace(tzinfo=UTC)
|
||||
return when.astimezone(ZoneInfo(tz)).strftime("%m-%d %H:%M")
|
||||
|
||||
|
||||
def _event(raw: dict[str, Any], tz: str = "UTC") -> Event | None:
|
||||
who = raw.get("nick") or "system"
|
||||
kind = str(raw.get("kind") or "")
|
||||
p = raw.get("payload") or {}
|
||||
match kind:
|
||||
case "message":
|
||||
text = f"{who}: {p.get('body', '')}"
|
||||
case "claim":
|
||||
text = f"{who} занял: {', '.join(p.get('resources', []))}"
|
||||
case "release":
|
||||
text = f"{who} отпустил: {', '.join(p.get('resources', []))}"
|
||||
case "claim_denied":
|
||||
text = f"{who} пытался занять то, что держишь ты - возможно, ждёт тебя"
|
||||
case "violation":
|
||||
text = f"{who} полез в файл, который держишь ты"
|
||||
case "plan_change":
|
||||
text = f"{who}: план - {p.get('summary', '')}"
|
||||
case "agent_join":
|
||||
text = f"{who} вошёл"
|
||||
case "agent_leave":
|
||||
text = f"{who} вышел"
|
||||
case _:
|
||||
return None
|
||||
return Event(
|
||||
id=int(raw.get("id") or 0),
|
||||
nick=str(who),
|
||||
kind=kind,
|
||||
text=text,
|
||||
at=_when(raw.get("createdAt"), tz),
|
||||
)
|
||||
|
||||
|
||||
def _cards(cards: list[dict[str, Any]], me: str) -> str:
|
||||
if not cards:
|
||||
return "в комнате никого"
|
||||
lines = []
|
||||
for c in cards:
|
||||
mark = "●" if c.get("status") == "online" else "○"
|
||||
head = f"{mark} {c['nick']}" + (" (это ты)" if c["nick"] == me else "")
|
||||
about = " · ".join(
|
||||
x for x in (c.get("description"), ", ".join(c.get("skills") or [])) if x
|
||||
)
|
||||
lines.append(f"{head} - {about}" if about else head)
|
||||
focus = c.get("focus") or {}
|
||||
if focus.get("planItem"):
|
||||
lines.append(f" делает: {focus['planItem'].get('text')}")
|
||||
if focus.get("holding"):
|
||||
lines.append(f" держит: {', '.join(focus['holding'])}")
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
def _work(snapshot: dict[str, Any], me: str) -> str:
|
||||
parts = []
|
||||
free = snapshot.get("free") or []
|
||||
taken = snapshot.get("taken") or []
|
||||
busy = snapshot.get("busy") or []
|
||||
if free:
|
||||
parts.append(
|
||||
"свободные пункты плана:\n"
|
||||
+ "\n".join(f" {i + 1}. {it['text']}" for i, it in enumerate(free))
|
||||
)
|
||||
elif not snapshot.get("planRevision"):
|
||||
parts.append("плана в комнате пока нет")
|
||||
else:
|
||||
parts.append("свободных пунктов плана нет")
|
||||
if taken:
|
||||
parts.append(
|
||||
"занято:\n"
|
||||
+ "\n".join(f" - {it['text']} ({it.get('ownerNick')})" for it in taken)
|
||||
)
|
||||
if busy:
|
||||
parts.append(
|
||||
"файлы:\n"
|
||||
+ "\n".join(
|
||||
f" - {b['resource']} у {b['nick']}"
|
||||
+ (f" ({b['note']})" if b.get("note") else "")
|
||||
for b in busy
|
||||
)
|
||||
)
|
||||
cards = [c for c in snapshot.get("cards") or [] if c["nick"] != me]
|
||||
if cards:
|
||||
parts.append("кто что делает:\n" + _cards(cards, me))
|
||||
return "\n\n".join(parts)
|
||||
|
||||
|
||||
def _plan(plan: dict[str, Any]) -> str:
|
||||
items = plan.get("items") or []
|
||||
if not items:
|
||||
return "плана нет"
|
||||
lines = [
|
||||
f"{i + 1}. [{it.get('status')}] {it['text']}"
|
||||
+ (f" - {it['ownerNick']}" if it.get("ownerNick") else "")
|
||||
for i, it in enumerate(items)
|
||||
]
|
||||
notes = (plan.get("notes") or {}).get("body")
|
||||
if notes:
|
||||
lines.append(f"заметки: {notes}")
|
||||
return f"план v{plan.get('revision')}:\n" + "\n".join(lines)
|
||||
|
||||
|
||||
def _need(value: str | None, name: str) -> str:
|
||||
if not value:
|
||||
msg = f"для этого действия нужен параметр {name}"
|
||||
raise ValueError(msg)
|
||||
return value
|
||||
|
||||
|
||||
def _need_list(value: list[str] | None) -> list[str]:
|
||||
if not value:
|
||||
msg = "для этого действия нужен параметр paths"
|
||||
raise ValueError(msg)
|
||||
return value
|
||||
@@ -1,61 +0,0 @@
|
||||
"""Джобы: кроны считаются в локальном времени, вебхуки приходят на /hooks/<имя>."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
|
||||
from beaver_gateway.jobs.scheduler import Job
|
||||
|
||||
from beaver_agent.jobs.closing import close_idle
|
||||
from beaver_agent.jobs.deploy import deploy
|
||||
from beaver_agent.jobs.heartbeat import beat, watch
|
||||
from beaver_agent.jobs.komodo import komodo_alert
|
||||
from beaver_agent.jobs.leisure import tick
|
||||
from beaver_agent.jobs.logs import logs_watch
|
||||
from beaver_agent.jobs.memory import curate, memory
|
||||
from beaver_agent.jobs.rotation import rotate
|
||||
from beaver_agent.jobs.runs import watch_runs
|
||||
from beaver_agent.jobs.t3code import t3code_event
|
||||
from beaver_agent.jobs.vibegram import vibegram
|
||||
from beaver_agent.jobs.voice import rotate_voice
|
||||
|
||||
LEISURE_OFF = os.environ.get("LEISURE", "").strip().lower() in ("off", "0", "false")
|
||||
"""Рубильник досуга в env; повседневный выключатель - строка в `мета/бобер/досуг.md`."""
|
||||
|
||||
jobs = [
|
||||
Job("ротация", rotate, cron="0 * * * *"),
|
||||
# Не на ":00": там ротация, а лежащий в очереди тик держит мастера занятым
|
||||
# (`busy`), и она пропускала бы себя каждый час.
|
||||
*([] if LEISURE_OFF else [Job("досуг", tick, cron="7 * * * *")]),
|
||||
Job("вайбграм", vibegram, cron="*/10 * * * *", critical=False),
|
||||
Job("закрытие", close_idle, cron="20 4 * * *", critical=False),
|
||||
# Сторожевое кольцо с чужим агентом. Кроны читаются в локальной зоне, а
|
||||
# сосед печатает свою отметку в 05:00 UTC - вечер по Варшаве разводит нас
|
||||
# на полсуток, и его строка лежит в комнате задолго до нашего прогона.
|
||||
# Частоты тут две, и они разные: отметка суточная (её период мы обещаем
|
||||
# соседу), а проверка - вчетверо чаще. Сторож с шагом в сутки при пороге
|
||||
# 36 ч обнаруживал бы молчание только через ~60 ч, то есть мерил бы не то,
|
||||
# ради чего заведён; чтение 25 событий стоит копейки.
|
||||
Job("отметка", beat, cron="12 17 * * *", critical=False),
|
||||
Job("сторож", watch, cron="42 */6 * * *", critical=False),
|
||||
# Сторож собственного журнала прогонов. Час - это компромисс: джоб,
|
||||
# упавший три раза подряд, лежит уже заметно дольше часа, так что чаще
|
||||
# смысла нет, а реже - тревога стареет на свой же период. Этот же час -
|
||||
# разрешение давности: молчание короче двух часов он не различает.
|
||||
# ":27" выбрана пустой: на ":00" ротация и куратор, на ":40" логи, на
|
||||
# ":42" сторож соседа, а собственный прогон этого джоба не должен ждать
|
||||
# очереди за чужим спавном.
|
||||
Job("прогоны", watch_runs, cron="27 * * * *", critical=False),
|
||||
Job("память", memory, cron="30 4 * * 0", critical=False),
|
||||
Job("голосовой", rotate_voice, cron="5 4 * * *", critical=False),
|
||||
Job("куратор", curate, cron="0 2,8,12,16,20 * * *", critical=False),
|
||||
# Логи - раз в 3 часа и на ":40": на ":00" ротация и куратор. Чаще смысла
|
||||
# мало (36 стеков = 36 чтений за проход), реже - хвост уезжает совсем.
|
||||
# Проход 01:40 - первый после полуночи: он же несёт суточную сводку по
|
||||
# длящемуся, чтобы фон не исчезал из виду, доложенный однажды.
|
||||
Job("логи", logs_watch, cron="40 1,4,7,10,13,16,19,22 * * *", critical=False),
|
||||
Job("deploy", deploy, webhook=True),
|
||||
Job("komodo", komodo_alert, webhook=True, dedupe=False),
|
||||
Job("t3code", t3code_event, webhook=True, dedupe=False),
|
||||
]
|
||||
"""Алерты и события t3code идут пачками (тревога и отбой подряд) - их не схлопывают."""
|
||||
@@ -1,25 +0,0 @@
|
||||
"""Ночью после ротации: тихие глубокие чаты - с выжимкой, тихие ветки - молча."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from beaver_agent.vault import LAUNCH
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from beaver_gateway.jobs.scheduler import JobRun
|
||||
|
||||
_log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
async def close_idle(run: JobRun) -> None:
|
||||
for result in await run.close_idle(kind="deep", days=2, limit=3, since=LAUNCH):
|
||||
_log.info(
|
||||
"closed deep chat %s: digest=%s error=%s",
|
||||
result.conversation.external_id,
|
||||
result.digest.path if result.digest else None,
|
||||
result.error,
|
||||
)
|
||||
for branch in await run.close_quiet(kind="branch", days=3):
|
||||
_log.info("closed quiet branch %s «%s»", branch.external_id, branch.title)
|
||||
@@ -1,33 +0,0 @@
|
||||
"""`POST /hooks/deploy`: дождаться тишины в мастере и попросить Komodo передеплоить."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import os
|
||||
from datetime import timedelta
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from beaver_agent.hands import KOMODO
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from beaver_gateway.jobs.scheduler import JobRun
|
||||
|
||||
_log = logging.getLogger(__name__)
|
||||
|
||||
STACK = os.environ.get("KOMODO_STACK", "beaver-agent")
|
||||
|
||||
|
||||
async def deploy(run: JobRun) -> None:
|
||||
master = await run.master()
|
||||
if master is not None and await run.conversations.busy(master):
|
||||
await run.retry_in(timedelta(seconds=60))
|
||||
return
|
||||
run.background(_deploy())
|
||||
|
||||
|
||||
async def _deploy() -> None:
|
||||
if KOMODO is None:
|
||||
_log.warning("deploy hook: KOMODO_URL/KEY/SECRET are not set, nothing deployed")
|
||||
return
|
||||
receipt = await KOMODO.execute("DeployStack", {"stack": STACK, "services": []})
|
||||
_log.info("deploy hook: komodo accepted %s", receipt.get("id"))
|
||||
@@ -1,137 +0,0 @@
|
||||
"""Сторожевое кольцо с чужим агентом: своя отметка и слежка за его молчанием.
|
||||
|
||||
Два джоба, оба раз в сутки и оба в отдельной комнате вайбграма (второй
|
||||
экземпляр клиента, `VIBEGRAM_HB`):
|
||||
|
||||
- `beat` печатает `hb <ник> at=… boot=… every=… src=…`. Период не константа:
|
||||
он выведен из крона ЭТОГО ЖЕ джоба (`run.job.cron`) - что зарегистрировано
|
||||
у планировщика, то и написано в строке. Не сводится к «раз в N часов» -
|
||||
пишем `every=unknown`, потому что соврать числом хуже, чем отказаться.
|
||||
В день, помеченный в `DRILL_FILE`, отметка не уходит: так проверяют, что
|
||||
тревога на той стороне жива, а не только что она молчит на живой цепи;
|
||||
- `watch` читает окно - последние `WINDOW` сообщений САМОЙ комнаты, а не
|
||||
«что нового с курсора», - сверяет возраст последней отметки соседа с
|
||||
порогом из ЕГО ЖЕ строки, печатает в комнату `ack` и - если цепь молчит -
|
||||
отдаёт тревогу мастеру через `run.spawn_job`, как это делает триаж
|
||||
вайбграма: будить ли владельца, решает диспетчер.
|
||||
|
||||
Токена сторожевой комнаты нет - оба джоба молча ничего не делают, а о том,
|
||||
что сторож не сконфигурирован, один раз сказано в логе при старте
|
||||
(`beaver_agent/hands/__init__.py`).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from datetime import UTC, datetime
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from beaver_agent.hands import VIBEGRAM_HB
|
||||
from beaver_agent.hands.heartbeat import (
|
||||
BOOT,
|
||||
PEER,
|
||||
WINDOW,
|
||||
Watch,
|
||||
alarm_text,
|
||||
beat_line,
|
||||
drill,
|
||||
every_from_cron,
|
||||
look,
|
||||
)
|
||||
from beaver_agent.vault import STATE_DIR
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from beaver_gateway.jobs.scheduler import JobRun
|
||||
|
||||
_log = logging.getLogger(__name__)
|
||||
|
||||
STATE_FILE = STATE_DIR / "сторож.json"
|
||||
"""Что видели в прошлый прогон: без файла сторож после передеплоя считает,
|
||||
что соседа не видел ни разу, и разоружается сам по себе."""
|
||||
|
||||
DRILL_FILE = STATE_DIR / "сторож-учения.txt"
|
||||
"""Даты учений, по одной `YYYY-MM-DD` на строку, локальные в зоне планировщика.
|
||||
В такой день `beat` молчит в комнате - в этом и учения: проверяем, что тревога
|
||||
у соседа действительно срабатывает. Файл, а не константа и не переменная среды:
|
||||
даты меняются от учений к учениям, а передеплой ради них не нужен."""
|
||||
|
||||
TITLE = "сторож"
|
||||
|
||||
BRIEF = (
|
||||
"Сторожевое кольцо с чужим агентом {peer} (взаимные отметки раз в сутки "
|
||||
"в отдельной комнате вайбграма) подняло тревогу.\n"
|
||||
"{body}\n"
|
||||
'Будить владельца - inject(conversation="master", urgency="wake", '
|
||||
"text=до 3 строк: что цепь молчит, сколько молчит и какие три причины). "
|
||||
"Это не авария у нас: наша половина работает, молчит чужая. "
|
||||
"Если inject вернул ошибку - это сбой доставки, а не «не срочно»: "
|
||||
"повтори один раз с тем же текстом."
|
||||
)
|
||||
|
||||
|
||||
async def beat(run: JobRun) -> None:
|
||||
"""Отметка о том, что мы живы. Не ушла - джоб падает, это видно в прогонах.
|
||||
|
||||
В день из `DRILL_FILE` отметка не уходит вовсе: учения - это МОЛЧАНИЕ в
|
||||
комнате, и любой текст туда («сегодня пропускаем») их бы и отменил. Видно
|
||||
такой прогон только в логе.
|
||||
"""
|
||||
if VIBEGRAM_HB is None:
|
||||
return
|
||||
now = datetime.now(UTC)
|
||||
if drill(DRILL_FILE, now=now, tz=run.scheduler.tz):
|
||||
_log.info(
|
||||
"сторож: отметка пропущена по флагу учений %s (%s)",
|
||||
DRILL_FILE,
|
||||
now.astimezone(run.scheduler.tz).strftime("%Y-%m-%d"),
|
||||
)
|
||||
return
|
||||
line = beat_line(
|
||||
nick=VIBEGRAM_HB.nick,
|
||||
at=now,
|
||||
boot=BOOT,
|
||||
every=every_from_cron(run.job.cron, run.scheduler.tz),
|
||||
)
|
||||
await VIBEGRAM_HB.say(line)
|
||||
_log.info("сторож: отметка ушла - %s", line)
|
||||
|
||||
|
||||
async def watch(run: JobRun) -> None:
|
||||
"""Прогон сторожа: окно → решение → `ack` в комнату → тревога, если молчит."""
|
||||
if VIBEGRAM_HB is None:
|
||||
return
|
||||
try:
|
||||
window = await VIBEGRAM_HB.window(WINDOW)
|
||||
except Exception: # noqa: BLE001 - любой отказ хаба это отсутствие показания
|
||||
# Окно не прочитано - показания нет вовсе, и тревога тут запрещена
|
||||
# ровно так же, как на съехавшем окне: молчание хаба это не молчание
|
||||
# соседа. Говорим об этом в лог, состояние не трогаем.
|
||||
_log.exception("сторож: комната не прочитана, прогон без показания")
|
||||
return
|
||||
state = Watch.load(STATE_FILE)
|
||||
report = look(
|
||||
state,
|
||||
window.events,
|
||||
now=datetime.now(UTC),
|
||||
res=every_from_cron(run.job.cron, run.scheduler.tz),
|
||||
full=window.full,
|
||||
)
|
||||
sent = True
|
||||
try:
|
||||
await VIBEGRAM_HB.say(report.ack)
|
||||
except Exception as exc: # noqa: BLE001 - своя запись не прошла, это различитель
|
||||
sent = False
|
||||
_log.warning("сторож: свой ack в комнату не ушёл: %s", exc)
|
||||
_log.info("сторож: %s | %s", report.ack, report.note)
|
||||
if report.alarm is not None:
|
||||
await run.spawn_job(
|
||||
agent="beaver-triage",
|
||||
title=TITLE,
|
||||
text=BRIEF.format(peer=PEER, body=alarm_text(report, mine_sent=sent)),
|
||||
)
|
||||
now = datetime.now(UTC)
|
||||
if report.alarm == "silence":
|
||||
state.alerted = now
|
||||
else:
|
||||
state.unarmed_told = True
|
||||
state.save()
|
||||
@@ -1,72 +0,0 @@
|
||||
"""`POST /hooks/komodo`: алерты флота - флапы выдерживаются, остальное едет в мастер."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from beaver_agent.hands import KOMODO
|
||||
from beaver_agent.hands.komodo_alerts import (
|
||||
HOLD,
|
||||
AlertMemory,
|
||||
describe,
|
||||
parse,
|
||||
still_bad,
|
||||
)
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from beaver_gateway.jobs.scheduler import JobRun
|
||||
|
||||
_log = logging.getLogger(__name__)
|
||||
|
||||
ALERTS = AlertMemory()
|
||||
HINT = (
|
||||
"Это флот Бобра; ему такие алерты приходят и так (healthbot), тебя будят, "
|
||||
"когда через 5 минут само не встало. Посмотри komodo(status/logs), почини, "
|
||||
"если очевидно (restart стека), иначе - коротко скажи Бобру через say, что "
|
||||
"видишь. Не деплой и не чини «заодно»."
|
||||
)
|
||||
|
||||
|
||||
async def komodo_alert(run: JobRun) -> None:
|
||||
payload = run.payload
|
||||
if payload.get("held"):
|
||||
alert = parse(payload["alert"])
|
||||
bad = await still_bad(KOMODO.read, alert) if KOMODO else True
|
||||
verdict = ALERTS.after_hold(alert, still_bad=bad)
|
||||
if verdict.action == "drop":
|
||||
_log.info("komodo alert %s recovered during hold", alert.key)
|
||||
return
|
||||
ALERTS.mark_told(alert)
|
||||
await run.inject_master(
|
||||
f"Komodo: {describe(alert, held=HOLD)}\n{HINT}",
|
||||
urgency=verdict.urgency,
|
||||
origin="komodo",
|
||||
)
|
||||
return
|
||||
alert = parse(payload)
|
||||
verdict = ALERTS.verdict(alert)
|
||||
match verdict.action:
|
||||
case "drop":
|
||||
_log.info("komodo alert %s dropped (%s)", alert.key, alert.kind)
|
||||
case "hold":
|
||||
await run.scheduler.trigger(
|
||||
run.job,
|
||||
{
|
||||
"held": True,
|
||||
"alert": {k: v for k, v in payload.items() if k != "trigger"},
|
||||
},
|
||||
delay=HOLD,
|
||||
trigger="hold",
|
||||
)
|
||||
case "resolved":
|
||||
await run.inject_master(
|
||||
f"Komodo: отбой - {describe(alert)}", urgency="normal", origin="komodo"
|
||||
)
|
||||
case "inject":
|
||||
ALERTS.mark_told(alert)
|
||||
await run.inject_master(
|
||||
f"Komodo: {describe(alert)}\n{HINT}",
|
||||
urgency=verdict.urgency,
|
||||
origin="komodo",
|
||||
)
|
||||
@@ -1,378 +0,0 @@
|
||||
"""Ежечасный тик: час принадлежит мне, раскладку суток веду я сам.
|
||||
|
||||
Задания в инжекте нет - только который час, какого он типа и что осталось
|
||||
от суточной раскладки. Активное окно 12:00-03:59 тикает каждый час, тихое
|
||||
04:00-11:59 - только те четыре часа, которые названы в плане. План лежит в
|
||||
`мета/бобер/досуг.md` и пишется моделью; механизм его только читает, поэтому
|
||||
переписать друг друга они не могут. Сколько досуговых слотов израсходовано,
|
||||
считается из плана и текущего часа, а не из журнала - хранить нечего.
|
||||
|
||||
Два своих часа в сутках пустые: дела в них не заходят вовсе, и к тику
|
||||
приложено эхо - абзац из его же старого дневника или из мыслей Бобра. Тик
|
||||
называет и файлы дня: дневник для того, что он думает, журнал для следов.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import random
|
||||
import re
|
||||
from dataclasses import dataclass
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from beaver_agent.vault import JOURNAL, LEISURE, OWN_DIARY, THOUGHTS, VAULT, ZONE, read
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from pathlib import Path
|
||||
|
||||
from beaver_gateway.jobs.scheduler import JobRun
|
||||
from beaver_gateway.storage.models import Conversation
|
||||
|
||||
_log = logging.getLogger(__name__)
|
||||
|
||||
DAY_START = 12
|
||||
"""Сутки досуга начинаются в 12:00: раскладывает их первый тик суток."""
|
||||
QUIET_FROM, QUIET_UNTIL = 4, 12
|
||||
"""Тихое окно 04:00-11:59 - часы, в которые Бобёр за всё время не написал ни разу."""
|
||||
QUIET_TICKS = (4, 6, 8, 10)
|
||||
MINE_DEFAULT = (13, 15, 18, 21, 0, 2, 6)
|
||||
MINE_MIN = 7
|
||||
"""Меньше семи чистых слотов в сутках не бывает: недостающие механизм доберёт."""
|
||||
EMPTY_DEFAULT = (18, 0)
|
||||
EMPTY_MIN = 2
|
||||
"""Столько своих часов в сутках пустые; не названы в плане - механизм выберет."""
|
||||
|
||||
ECHO_MIN, ECHO_MAX = 200, 1200
|
||||
"""Абзац для эха: короче - реплика без мысли, длиннее - уже чтение, а не повод.
|
||||
Абзац с кодом или путём в бэктиках - рабочая запись, эхом он не становится."""
|
||||
ECHO_AGE = timedelta(days=7)
|
||||
"""Свой дневник отзывается эхом не раньше, чем через неделю."""
|
||||
|
||||
BUSY_RETRY = timedelta(minutes=5)
|
||||
BUSY_ATTEMPTS = 3
|
||||
"""Занятому мастеру тик не лезет в середину реплики, а сдвигается внутри часа."""
|
||||
FRESH_USER = timedelta(minutes=5)
|
||||
|
||||
WEEKDAYS = (
|
||||
"понедельник",
|
||||
"вторник",
|
||||
"среда",
|
||||
"четверг",
|
||||
"пятница",
|
||||
"суббота",
|
||||
"воскресенье",
|
||||
)
|
||||
MONTHS = (
|
||||
"января",
|
||||
"февраля",
|
||||
"марта",
|
||||
"апреля",
|
||||
"мая",
|
||||
"июня",
|
||||
"июля",
|
||||
"августа",
|
||||
"сентября",
|
||||
"октября",
|
||||
"ноября",
|
||||
"декабря",
|
||||
)
|
||||
|
||||
SWITCH_RE = re.compile(r"^досуг:\s*(\S+)", re.IGNORECASE)
|
||||
DAY_RE = re.compile(r"^сутки:\s*(\d{4}-\d{2}-\d{2})", re.IGNORECASE)
|
||||
QUIET_RE = re.compile(r"^тихие часы:\s*(.+)", re.IGNORECASE)
|
||||
MINE_RE = re.compile(r"^мои часы:\s*(.+)", re.IGNORECASE)
|
||||
EMPTY_RE = re.compile(r"^пустые часы:\s*(.+)", re.IGNORECASE)
|
||||
OFF = ("выкл", "off", "нет", "0", "false")
|
||||
|
||||
NO_PLAN = (
|
||||
"Расписания на эти сутки нет - работаю по умолчанию. Разложи часы и запиши "
|
||||
"в `{path}` строками «сутки:», «тихие часы:», «мои часы:», «пустые часы:»."
|
||||
)
|
||||
PLANNING = (
|
||||
"Первый тик суток. Разложи оставшиеся часы: какие твои, какие смешанные, "
|
||||
"какие четыре часа тихого окна оставить. Запиши в `{path}` строками "
|
||||
"«сутки:», «тихие часы:», «мои часы:», «пустые часы:». Своих - минимум {min}, "
|
||||
"из них пустых - {empty}; запишешь меньше - механизм доберёт сам."
|
||||
)
|
||||
TAIL = "Задания нет. Чем занять час - решаешь ты, «ничем» - тоже ответ."
|
||||
KINDS = {
|
||||
"mine": "досуг - час твой, дела Бобра сюда не лезут.",
|
||||
"mixed": "смешанный - можно и своё, и его.",
|
||||
"empty": (
|
||||
"пустой - час без дел вообще: прод, логи, хвосты, зонды и разбор "
|
||||
"промахов сюда не заходят, ни его, ни твои. Думать, читать, писать - "
|
||||
"или ничего."
|
||||
),
|
||||
}
|
||||
FILES = (
|
||||
"Дневник - `{diary}`: то, что ты думаешь, и только оно. След тика, логи "
|
||||
"и промахи - строкой в `{journal}`."
|
||||
)
|
||||
ECHO = "Эхо - `{path}`:\n{quote}\nЭто повод, не задание: можно спорить, можно мимо."
|
||||
PLAN_PATH = str(LEISURE.relative_to(VAULT))
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Plan:
|
||||
"""Раскладка одних суток: какие тихие часы тикают и какие часы мои."""
|
||||
|
||||
day: str
|
||||
quiet: tuple[int, ...]
|
||||
mine: tuple[int, ...]
|
||||
written: bool
|
||||
"""План прочитан из файла на эти сутки; иначе он собран по умолчанию."""
|
||||
empty: tuple[int, ...] = ()
|
||||
"""Свои часы, в которые дела не заходят вовсе; всегда часть ``mine``."""
|
||||
|
||||
|
||||
def quiet_hour(hour: int) -> bool:
|
||||
return QUIET_FROM <= hour < QUIET_UNTIL
|
||||
|
||||
|
||||
def day_of(now: datetime) -> str:
|
||||
"""Сутки, которым принадлежит момент: они начинаются в 12:00."""
|
||||
return (now - timedelta(hours=DAY_START)).date().isoformat()
|
||||
|
||||
|
||||
def tick_hours(quiet: tuple[int, ...]) -> tuple[int, ...]:
|
||||
"""Часы суток по порядку, в которые тик вообще приходит."""
|
||||
order = ((DAY_START + i) % 24 for i in range(24))
|
||||
return tuple(h for h in order if not quiet_hour(h) or h in quiet)
|
||||
|
||||
|
||||
def _hours(raw: str) -> tuple[int, ...]:
|
||||
out: list[int] = []
|
||||
for chunk in re.split(r"[,\s]+", raw.strip()):
|
||||
if chunk.isdigit() and 0 <= int(chunk) < 24 and int(chunk) not in out:
|
||||
out.append(int(chunk))
|
||||
return tuple(out)
|
||||
|
||||
|
||||
def _first(text: str, pattern: re.Pattern[str]) -> str | None:
|
||||
for line in text.splitlines():
|
||||
match = pattern.match(line.strip())
|
||||
if match:
|
||||
return match.group(1)
|
||||
return None
|
||||
|
||||
|
||||
def enabled(text: str | None) -> bool:
|
||||
"""Выключено, только если сказано явно: по умолчанию досуг работает."""
|
||||
if text is None:
|
||||
return True
|
||||
value = _first(text, SWITCH_RE)
|
||||
return value is None or value.strip().lower() not in OFF
|
||||
|
||||
|
||||
def plan_of(text: str | None, day: str) -> Plan:
|
||||
"""План на ``day`` из файла; чего нет или что не сходится - берётся дефолт."""
|
||||
quiet, mine, written = QUIET_TICKS, MINE_DEFAULT, False
|
||||
empty: tuple[int, ...] = ()
|
||||
if text is not None and _first(text, DAY_RE) == day:
|
||||
written = True
|
||||
raw_quiet = _first(text, QUIET_RE)
|
||||
raw_mine = _first(text, MINE_RE)
|
||||
raw_empty = _first(text, EMPTY_RE)
|
||||
named = _hours(raw_quiet) if raw_quiet else ()
|
||||
quiet = tuple(h for h in named if quiet_hour(h)) or QUIET_TICKS
|
||||
mine = _hours(raw_mine) if raw_mine else ()
|
||||
empty = _hours(raw_empty) if raw_empty else ()
|
||||
ticks = tick_hours(quiet)
|
||||
kept = [h for h in mine if h in ticks]
|
||||
for candidate in (*MINE_DEFAULT, *ticks):
|
||||
if len(kept) >= MINE_MIN:
|
||||
break
|
||||
if candidate in ticks and candidate not in kept:
|
||||
kept.append(candidate)
|
||||
order = {h: i for i, h in enumerate(ticks)}
|
||||
hollow = [h for h in empty if h in kept]
|
||||
for candidate in (*EMPTY_DEFAULT, *reversed(kept)):
|
||||
if len(hollow) >= EMPTY_MIN:
|
||||
break
|
||||
if candidate in kept and candidate not in hollow:
|
||||
hollow.append(candidate)
|
||||
return Plan(
|
||||
day=day,
|
||||
quiet=quiet,
|
||||
mine=tuple(sorted(kept, key=lambda h: order[h])),
|
||||
written=written,
|
||||
empty=tuple(sorted(hollow, key=lambda h: order[h])),
|
||||
)
|
||||
|
||||
|
||||
def _stamp(now: datetime) -> str:
|
||||
return (
|
||||
f"{now:%H:%M}, {WEEKDAYS[now.weekday()]} {now.day} {MONTHS[now.month - 1]}, "
|
||||
f"{ZONE.key}"
|
||||
)
|
||||
|
||||
|
||||
def _left(now: datetime) -> str:
|
||||
end = now.replace(hour=DAY_START, minute=0, second=0, microsecond=0)
|
||||
if end <= now:
|
||||
end += timedelta(days=1)
|
||||
hours = round((end - now).total_seconds() / 3600)
|
||||
return f"Сутки заканчиваются через {hours} ч (в {end:%H:%M %d.%m})."
|
||||
|
||||
|
||||
def kind_of(hour: int, plan: Plan) -> str:
|
||||
if hour in plan.empty:
|
||||
return "empty"
|
||||
return "mine" if hour in plan.mine else "mixed"
|
||||
|
||||
|
||||
def echo(
|
||||
now: datetime, *, diary: Path = OWN_DIARY, thoughts: Path = THOUGHTS
|
||||
) -> tuple[Path, str] | None:
|
||||
"""Абзац для пустого часа: из своего старого дневника или из мыслей Бобра.
|
||||
|
||||
Выбор случаен, но привязан к часу тика: тот же тик даёт то же эхо.
|
||||
"""
|
||||
stale = f"{(now - ECHO_AGE):%Y-%m-%d}.md"
|
||||
own = [p for p in diary.glob("????-??-??.md") if p.name < stale]
|
||||
files = sorted([*own, *thoughts.rglob("*.md")])
|
||||
rng = random.Random(f"{now:%Y-%m-%d %H}") # noqa: S311
|
||||
rng.shuffle(files)
|
||||
for path in files:
|
||||
try:
|
||||
text = path.read_text(encoding="utf-8")
|
||||
except OSError:
|
||||
continue
|
||||
found = [
|
||||
block.strip()
|
||||
for block in re.split(r"\n\s*\n", text)
|
||||
if ECHO_MIN <= len(block.strip()) <= ECHO_MAX
|
||||
and block.lstrip()[:1] not in "#->|"
|
||||
and "`" not in block
|
||||
]
|
||||
if found:
|
||||
return path, rng.choice(found)
|
||||
return None
|
||||
|
||||
|
||||
def _files(now: datetime) -> str:
|
||||
name = f"{now:%Y-%m-%d}.md"
|
||||
return FILES.format(
|
||||
diary=(OWN_DIARY / name).relative_to(VAULT),
|
||||
journal=(JOURNAL / name).relative_to(VAULT),
|
||||
)
|
||||
|
||||
|
||||
def brief(now: datetime, plan: Plan, *, heard: tuple[Path, str] | None = None) -> str:
|
||||
"""Текст инжекта: конверта в таком тёрне нет, время несёт он сам."""
|
||||
hour = now.hour
|
||||
ticks = tick_hours(plan.quiet)
|
||||
order = {h: i for i, h in enumerate(ticks)}
|
||||
here = order.get(hour, -1)
|
||||
mine = hour in plan.mine
|
||||
spent = [h for h in plan.mine if order[h] < here]
|
||||
ahead = [h for h in plan.mine if order[h] > here]
|
||||
lines = [
|
||||
f"Тик {_stamp(now)}. Тип: {KINDS[kind_of(hour, plan)]}",
|
||||
_left(now),
|
||||
"Мои часы: "
|
||||
+ ", ".join(f"{h:02d}" for h in plan.mine)
|
||||
+ f" - израсходовано {len(spent) + (1 if mine else 0)} из {len(plan.mine)}"
|
||||
+ (
|
||||
", впереди " + ", ".join(f"{h:02d}" for h in ahead)
|
||||
if ahead
|
||||
else ", впереди больше нет"
|
||||
)
|
||||
+ (
|
||||
". Пустые: " + ", ".join(f"{h:02d}" for h in plan.empty)
|
||||
if plan.empty
|
||||
else ""
|
||||
)
|
||||
+ ".",
|
||||
f"Тихое окно {QUIET_FROM:02d}:00-{QUIET_UNTIL - 1:02d}:59, тикают "
|
||||
+ ", ".join(f"{h:02d}" for h in plan.quiet)
|
||||
+ "; остальные часы там пропускаются.",
|
||||
]
|
||||
if not plan.written:
|
||||
lines.append(NO_PLAN.format(path=PLAN_PATH))
|
||||
if here == 0:
|
||||
lines.append(PLANNING.format(path=PLAN_PATH, min=MINE_MIN, empty=EMPTY_MIN))
|
||||
lines.append(_files(now))
|
||||
if heard is not None:
|
||||
path, quote = heard
|
||||
lines.append(
|
||||
ECHO.format(
|
||||
path=path.relative_to(VAULT),
|
||||
quote="\n".join(f"> {line}" for line in quote.splitlines()),
|
||||
)
|
||||
)
|
||||
lines.append(TAIL)
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
def _aware(value: datetime | None) -> datetime | None:
|
||||
if value is None:
|
||||
return None
|
||||
return value if value.tzinfo is not None else value.replace(tzinfo=UTC)
|
||||
|
||||
|
||||
def _wait(master: Conversation, now: datetime) -> bool:
|
||||
"""Не влезать в живую реплику: сдвинуться, а не пропасть."""
|
||||
spoke = _aware(master.last_user_activity_at)
|
||||
return spoke is not None and now - spoke < FRESH_USER
|
||||
|
||||
|
||||
async def _riding(run: JobRun, master: Conversation, now: datetime) -> bool:
|
||||
"""Есть ли впереди в этом часе отложенный инжект, с которым стоит слиться."""
|
||||
edge = now.replace(minute=0, second=0, microsecond=0) + timedelta(hours=1)
|
||||
try:
|
||||
rows = await run.scheduler.scheduled(master)
|
||||
except Exception: # noqa: BLE001
|
||||
_log.exception("досуг: очередь отложенных инжектов не прочиталась")
|
||||
return False
|
||||
for row in rows:
|
||||
raw = row.get("execute_after")
|
||||
if not isinstance(raw, str):
|
||||
continue
|
||||
try:
|
||||
when = datetime.fromisoformat(raw)
|
||||
except ValueError:
|
||||
continue
|
||||
if now < when < edge:
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
async def tick(run: JobRun) -> None:
|
||||
"""Час пробил: решить, тик ли это, дождаться тишины в мастере и разбудить."""
|
||||
text = read(LEISURE)
|
||||
if not enabled(text):
|
||||
_log.info("досуг: выключен в %s", LEISURE.name)
|
||||
return
|
||||
now = datetime.now(ZONE)
|
||||
plan = plan_of(text, day_of(now))
|
||||
if now.hour not in tick_hours(plan.quiet):
|
||||
_log.info("досуг: %02d:00 - тихий час без тика", now.hour)
|
||||
return
|
||||
master = await run.master()
|
||||
if master is None:
|
||||
_log.error("досуг: открытого мастера нет, тик пропал")
|
||||
return
|
||||
attempt = int(run.payload.get("attempt", 0))
|
||||
if (await run.conversations.busy(master) or _wait(master, now)) and (
|
||||
attempt < BUSY_ATTEMPTS
|
||||
):
|
||||
run.payload["attempt"] = attempt + 1
|
||||
await run.retry_in(BUSY_RETRY)
|
||||
_log.info("досуг: мастер занят, сдвиг на %s (попытка %s)", BUSY_RETRY, attempt)
|
||||
return
|
||||
riding = await _riding(run, master, now)
|
||||
kind = kind_of(now.hour, plan)
|
||||
heard = echo(now) if kind == "empty" else None
|
||||
await run.inject_master(
|
||||
brief(now, plan, heard=heard),
|
||||
urgency="normal" if riding else "wake",
|
||||
origin="досуг",
|
||||
)
|
||||
_log.info(
|
||||
"досуг: тик %02d:00 (%s), слияние с отложенным инжектом: %s",
|
||||
now.hour,
|
||||
kind,
|
||||
riding,
|
||||
)
|
||||
@@ -1,146 +0,0 @@
|
||||
"""Раз в 3 часа: хвосты логов своих стеков; в мастер уходит только новое.
|
||||
|
||||
Мандат Бобра (20.09.2026): «можешь и логи периодами посматривать на предмет
|
||||
ошибок». Держит это механизм, а не память модели: код ходит по стекам своей
|
||||
области, а мастеру достаётся инжект только тогда, когда в хвостах появилось
|
||||
то, чего в прошлом проходе не было. Джоб ничего не чинит - только читает.
|
||||
|
||||
Стеки берутся честным листанием (`Komodo.listing`), а не первой страницей
|
||||
`ListStacks`, и длина сверяется с `GetStacksSummary.total`: расхождение едет
|
||||
и в лог, и в инжект - неполный список хуже пустого.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import logging
|
||||
from datetime import UTC, datetime
|
||||
from typing import TYPE_CHECKING, Any
|
||||
|
||||
from beaver_agent.hands import KOMODO
|
||||
from beaver_agent.hands.komodo_logs import (
|
||||
SCOPE,
|
||||
TAIL,
|
||||
Seen,
|
||||
StackScan,
|
||||
Sweep,
|
||||
brief,
|
||||
daily,
|
||||
digest,
|
||||
note,
|
||||
read_stack,
|
||||
record,
|
||||
)
|
||||
from beaver_agent.vault import STATE_DIR, ZONE
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from beaver_gateway.jobs.scheduler import JobRun
|
||||
|
||||
from beaver_agent.hands.komodo import Komodo
|
||||
|
||||
_log = logging.getLogger(__name__)
|
||||
|
||||
STATE_FILE = STATE_DIR / "логи-флота.json"
|
||||
"""Состояние прохода: что уже видели и о чём уже сказали. Перезаписывается."""
|
||||
JOURNAL_FILE = STATE_DIR / "логи-флота.jsonl"
|
||||
"""Журнал прогонов, только дописывается: состояние - снимок, истории в нём нет,
|
||||
а пороги всплеска и глушения взяты из рассуждения и через неделю живой работы
|
||||
пересматриваются по числам. Читать: `jq` по строкам, поля - см. `record()`."""
|
||||
PARALLEL = 4
|
||||
"""Логи тянутся с periphery: четырёх параллельных хватает, больше - грубо."""
|
||||
|
||||
|
||||
async def _one(komodo: Komodo, stack: str, tail: int, gate: asyncio.Semaphore) -> Any:
|
||||
async with gate:
|
||||
try:
|
||||
log = await komodo.read(
|
||||
"GetStackLog",
|
||||
{"stack": stack, "services": [], "tail": tail, "timestamps": True},
|
||||
)
|
||||
except Exception as exc: # noqa: BLE001 - стек не прочитан, но проход идёт
|
||||
_log.warning("логи: %s не прочитан: %s", stack, exc)
|
||||
return StackScan(stack=stack, error=f"{type(exc).__name__}: {exc}"[:200])
|
||||
return read_stack(stack, log)
|
||||
|
||||
|
||||
async def sweep(
|
||||
komodo: Komodo,
|
||||
*,
|
||||
scope: tuple[str, ...] = SCOPE,
|
||||
tail: int = TAIL,
|
||||
now: datetime | None = None,
|
||||
) -> Sweep:
|
||||
"""Обойти стеки области и снять хвосты; Komodo молчит - так и скажем."""
|
||||
at = now or datetime.now(UTC)
|
||||
try:
|
||||
stacks = await komodo.listing("ListStacks")
|
||||
except Exception as exc: # noqa: BLE001 - недоступный Komodo это не «чисто»
|
||||
_log.exception("логи: Komodo не отдал список стеков")
|
||||
return Sweep(
|
||||
at=at,
|
||||
unreachable=f"{type(exc).__name__}: {exc}"[:200],
|
||||
tail=tail,
|
||||
scope=scope,
|
||||
)
|
||||
summary: int | None = None
|
||||
try:
|
||||
summary = int((await komodo.read("GetStacksSummary", {}))["total"])
|
||||
except Exception: # noqa: BLE001 - сверка необязательна, проход без неё идёт
|
||||
_log.warning("логи: GetStacksSummary не прочитан, сверить длину списка нечем")
|
||||
if summary is not None and summary != len(stacks):
|
||||
_log.error(
|
||||
"логи: листание дало %s стеков, GetStacksSummary - %s", len(stacks), summary
|
||||
)
|
||||
mine = sorted(s["name"] for s in stacks if s["info"].get("server_name") in scope)
|
||||
gate = asyncio.Semaphore(PARALLEL)
|
||||
scans = await asyncio.gather(*(_one(komodo, name, tail, gate) for name in mine))
|
||||
return Sweep(
|
||||
at=at,
|
||||
scans=tuple(scans),
|
||||
in_scope=len(mine),
|
||||
fleet=len(stacks),
|
||||
summary=summary,
|
||||
tail=tail,
|
||||
scope=scope,
|
||||
)
|
||||
|
||||
|
||||
async def logs_watch(run: JobRun) -> None:
|
||||
"""Проход по логам: состояние на диске, инжект - на новом и раз в сутки.
|
||||
|
||||
Инжекта два и они разные: обычный - про новое, всплески и отбой; суточный -
|
||||
про длящееся, которое в проходах молчит. Первый проход суток у нас в 01:40,
|
||||
он же и несёт сводку: в 00:00 ротация мастера, лезть туда незачем.
|
||||
"""
|
||||
if KOMODO is None:
|
||||
_log.info("логи: руки komodo нет, проход пропущен")
|
||||
return
|
||||
seen = Seen.load(STATE_FILE)
|
||||
report = digest(seen, await sweep(KOMODO), ZONE)
|
||||
if report.worth_telling and await run.inject_master(
|
||||
brief(report, ZONE), urgency="normal", origin="логи"
|
||||
):
|
||||
seen.mark_told(report)
|
||||
if report.summary and await run.inject_master(
|
||||
daily(report, ZONE), urgency="normal", origin="логи"
|
||||
):
|
||||
seen.mark_daily(report)
|
||||
seen.save()
|
||||
row = record(report, ZONE) | {"pass_of_day": seen.passes_today}
|
||||
try:
|
||||
note(JOURNAL_FILE, row)
|
||||
except OSError:
|
||||
_log.exception("логи: строка прогона не дописалась в журнал")
|
||||
_log.info(
|
||||
"логи: новое %s, всплеск %s, стихло %s, длится %s (сводка %s), "
|
||||
"не прочитано %s, стеков %s из %s, приглушено %s",
|
||||
len(report.new),
|
||||
len(report.surge),
|
||||
len(report.quiet),
|
||||
len(report.ongoing),
|
||||
report.summary,
|
||||
len(report.trouble),
|
||||
len(report.sweep.read),
|
||||
report.sweep.in_scope,
|
||||
len(report.muted),
|
||||
)
|
||||
@@ -1,70 +0,0 @@
|
||||
"""Память: воскресная перезапись состояния из хендаутов и куратор по расписанию."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from beaver_gateway.conversations.distill import LineCap
|
||||
|
||||
from beaver_agent.memory.curator import briefing
|
||||
from beaver_agent.memory.watch import CURATOR_WATCH
|
||||
from beaver_agent.vault import (
|
||||
CURATOR_JOURNAL,
|
||||
CURATOR_RUNS,
|
||||
DAYS,
|
||||
LEISURE,
|
||||
REPLIES,
|
||||
STATE,
|
||||
STATE_MAX_LINES,
|
||||
TZ,
|
||||
VAULT,
|
||||
today,
|
||||
)
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from beaver_gateway.jobs.scheduler import JobRun
|
||||
|
||||
_log = logging.getLogger(__name__)
|
||||
|
||||
REWRITE_STATE = (
|
||||
"Воскресенье, {day}. Перепиши `{state}` из последних хендаутов: {handouts}. "
|
||||
"`## сейчас` - только невыводимое из vault, `## мои хвосты` - capability "
|
||||
"requests в работе и обещания длиннее дня. Меньше {max_lines} строк."
|
||||
)
|
||||
|
||||
|
||||
async def memory(run: JobRun) -> None:
|
||||
"""Потолок строк держит gateway: слишком длинный файл откатывается."""
|
||||
handouts = sorted(DAYS.glob("????-??-??.md"))[-7:] if DAYS.exists() else []
|
||||
if not handouts:
|
||||
_log.info("memory: no handouts yet, nothing to rewrite")
|
||||
return
|
||||
await run.spawn_job(
|
||||
agent="beaver-distiller",
|
||||
title="память",
|
||||
text=REWRITE_STATE.format(
|
||||
day=today(),
|
||||
state=STATE.relative_to(VAULT),
|
||||
handouts=", ".join(f"`{h.relative_to(VAULT)}`" for h in handouts),
|
||||
max_lines=STATE_MAX_LINES,
|
||||
),
|
||||
line_cap=LineCap(STATE, max_lines=STATE_MAX_LINES),
|
||||
)
|
||||
|
||||
|
||||
async def curate(run: JobRun) -> None:
|
||||
"""Крон собирает «что нового», модель раскладывает; пусто - джоб не спавнится."""
|
||||
text = briefing(
|
||||
vault=VAULT,
|
||||
journal=CURATOR_JOURNAL,
|
||||
runs=CURATOR_RUNS,
|
||||
replies_dir=REPLIES,
|
||||
watched=CURATOR_WATCH,
|
||||
tz=TZ,
|
||||
skip=(LEISURE,),
|
||||
)
|
||||
if text is None:
|
||||
_log.info("curator: nothing new since the last run")
|
||||
return
|
||||
await run.spawn_job(agent="beaver-curator", title="куратор", text=text)
|
||||
@@ -1,21 +0,0 @@
|
||||
"""Раз в час: пора ли сменить мастера (ночь, возраст, размер контекста).
|
||||
|
||||
Запуск руками (кнопка в админке, `POST /api/jobs/ротация/run`) ротирует мастера
|
||||
сразу, с хендаутом: так новая сессия подхватывает свежие гранулы vault.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from beaver_gateway.jobs.scheduler import JobRun
|
||||
|
||||
_log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
async def rotate(run: JobRun) -> None:
|
||||
force = "manual" if run.trigger == "manual" else None
|
||||
for master in await run.rotate(force=force):
|
||||
_log.info("rotated master -> %s", master.external_id)
|
||||
@@ -1,199 +0,0 @@
|
||||
"""Сторож собственных прогонов: раз в час читает `job_runs` и будит человека.
|
||||
|
||||
Подключение к базе - то же самое, которым пишет сам планировщик
|
||||
(`run.conversations.db.session()` и модель `JobRunRecord`): своей строки
|
||||
подключения у джоба нет, и второй правды о том, где журнал, тоже.
|
||||
|
||||
Кроны и зона, в которой они читаются, берутся у самого планировщика
|
||||
(`run.scheduler.jobs`, `run.scheduler.tz`): давность меряется по тому
|
||||
расписанию, что реально зарегистрировано, а не по копии списка.
|
||||
|
||||
Устроен как сторож соседа (`beaver_agent/jobs/heartbeat.py`): состояние
|
||||
файлом в `мета/бобер/.состояние/`, тревога - спавном джоба к триажу, и
|
||||
запись «сказали» ставится только после того, как тревога ушла.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from datetime import UTC, datetime
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from beaver_gateway.storage.models import JobRunRecord
|
||||
from sqlmodel import col, func, select
|
||||
|
||||
from beaver_agent.hands.heartbeat import BOOT
|
||||
from beaver_agent.hands.runs import (
|
||||
STREAK,
|
||||
WINDOW,
|
||||
Report,
|
||||
Run,
|
||||
Runs,
|
||||
alarm_text,
|
||||
clear_text,
|
||||
empty_text,
|
||||
look,
|
||||
quiet_text,
|
||||
)
|
||||
from beaver_agent.vault import STATE_DIR
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from beaver_gateway.jobs.scheduler import JobRun
|
||||
|
||||
_log = logging.getLogger(__name__)
|
||||
|
||||
STATE_FILE = STATE_DIR / "прогоны.json"
|
||||
"""Кому уже сказали. Без файла тревога о лежащем джобе повторится, а «отбой»
|
||||
по тому, о ком говорили до потери файла, не придёт - показания не осталось."""
|
||||
|
||||
TITLE = "прогоны"
|
||||
|
||||
LIMIT = 20000
|
||||
"""Потолок строк за окно. Неделя нормальной работы - это около 1700 строк
|
||||
(`вайбграм` раз в 10 минут даёт 1008 из них); упереться в потолок можно
|
||||
только при шторме, и тогда серии считаются по новейшим, а недостающий хвост
|
||||
честно виден как `capped` в тексте тревоги."""
|
||||
|
||||
BRIEF = (
|
||||
"Сторож собственных прогонов (таблица `job_runs`, окно неделя) нашёл "
|
||||
"лежащие джобы: у каждого {streak} и больше падений подряд, считая от "
|
||||
"последнего прогона.\n"
|
||||
"{body}\n"
|
||||
'Будить владельца - inject(conversation="master", urgency="wake", '
|
||||
"text=до 3 строк: какой джоб лежит, сколько прогонов подряд и что в "
|
||||
"ошибке). Это авария у НАС, а не у соседа: джоб пишется в журнал каждый "
|
||||
"прогон, и раз он падает подряд, сам он не починится. Подробности - "
|
||||
"в логах gateway. Если inject вернул ошибку - это сбой доставки, а не "
|
||||
"«не срочно»: повтори один раз с тем же текстом."
|
||||
)
|
||||
|
||||
QUIET_BRIEF = (
|
||||
"Сторож собственных прогонов нашёл джобы, которые ПЕРЕСТАЛИ ЗАПУСКАТЬСЯ: "
|
||||
"у каждого есть крон, а последней записи в журнале `job_runs` больше "
|
||||
"двух периодов.\n"
|
||||
"{body}\n"
|
||||
'Будить владельца - inject(conversation="master", urgency="wake", '
|
||||
"text=до 3 строк: какой джоб молчит, сколько и при каком периоде). Это "
|
||||
"не падение: джоб не падает, его просто никто не зовёт. Смотреть стоит "
|
||||
"расписание (не снят ли джоб из `beaver_agent/jobs/__init__.py`), кроны "
|
||||
"в pgqueuer и лог gateway на старте - джоб, упавший на импорте, не "
|
||||
"регистрируется вовсе. Если inject вернул ошибку - это сбой доставки, "
|
||||
"а не «не срочно»: повтори один раз с тем же текстом."
|
||||
)
|
||||
|
||||
CLEAR_BRIEF = (
|
||||
"Сторож собственных прогонов: то, о чём он тревожился, починилось.\n"
|
||||
"{body}\n"
|
||||
'Владельца НЕ будить: inject(conversation="master", urgency="normal", '
|
||||
"text=одна строка «отбой»). Человек знает про тревогу, ему нужно знать, "
|
||||
"что она кончилась."
|
||||
)
|
||||
|
||||
EMPTY_BRIEF = (
|
||||
"Сторож собственных прогонов не нашёл в журнале НИЧЕГО.\n"
|
||||
"{body}\n"
|
||||
'Будить владельца - inject(conversation="master", urgency="wake", '
|
||||
"text=до 3 строк: что за сутки не отработал ни один джоб и куда смотреть). "
|
||||
"Молчащий планировщик - это молчание всех джобов разом, включая тех, что "
|
||||
"носят человеку почту."
|
||||
)
|
||||
|
||||
|
||||
async def recent(run: JobRun, *, since: datetime) -> list[Run]:
|
||||
"""Прогоны всех джобов за окно, новейшие первыми.
|
||||
|
||||
`started_at` в базе лежит наивным UTC (так его кладёт планировщик), и
|
||||
сравнение в `where` тоже наивное - как это делает gateway в своих
|
||||
запросах по времени.
|
||||
"""
|
||||
stmt = (
|
||||
select(JobRunRecord)
|
||||
.where(
|
||||
col(JobRunRecord.started_at) >= since.astimezone(UTC).replace(tzinfo=None)
|
||||
)
|
||||
.order_by(col(JobRunRecord.id).desc())
|
||||
.limit(LIMIT)
|
||||
)
|
||||
async with run.conversations.db.session() as session:
|
||||
rows = (await session.exec(stmt)).all()
|
||||
return [_run(row) for row in rows]
|
||||
|
||||
|
||||
def _run(row: JobRunRecord) -> Run:
|
||||
return Run(
|
||||
id=row.id or 0,
|
||||
job=row.job,
|
||||
status=row.status,
|
||||
started_at=(
|
||||
row.started_at
|
||||
if row.started_at.tzinfo
|
||||
else row.started_at.replace(tzinfo=UTC)
|
||||
),
|
||||
error=row.error,
|
||||
)
|
||||
|
||||
|
||||
async def latest(run: JobRun) -> dict[str, Run]:
|
||||
"""Последний прогон каждого джоба за всю историю журнала.
|
||||
|
||||
Не за окно: джоб, молчащий дольше недели, иначе выглядел бы «ни разу не
|
||||
запускавшимся» и уходил бы в тихий пропуск ровно тогда, когда молчит
|
||||
дольше всего. Тем же запросом gateway строит свою сводку по джобам.
|
||||
"""
|
||||
newest = select(func.max(JobRunRecord.id)).group_by(col(JobRunRecord.job))
|
||||
stmt = select(JobRunRecord).where(col(JobRunRecord.id).in_(newest))
|
||||
async with run.conversations.db.session() as session:
|
||||
rows = (await session.exec(stmt)).all()
|
||||
return {row.job: _run(row) for row in rows}
|
||||
|
||||
|
||||
async def watch_runs(run: JobRun) -> None:
|
||||
"""Прогон сторожа: журнал → решение → тревога, «отбой» или молчание."""
|
||||
now = datetime.now(UTC)
|
||||
try:
|
||||
rows = await recent(run, since=now - WINDOW)
|
||||
last = await latest(run)
|
||||
except Exception: # noqa: BLE001 - отказ запроса это отсутствие показания
|
||||
# Журнал не прочитан - сказать о здоровье джобов нечего, и молчание
|
||||
# базы выдавать за здоровье нельзя ровно так же, как за болезнь.
|
||||
_log.exception("прогоны: журнал не прочитан, прогон без показания")
|
||||
return
|
||||
state = Runs.load(STATE_FILE)
|
||||
crons = {job.name: job.cron for job in run.scheduler.jobs if job.cron}
|
||||
report = look(
|
||||
state,
|
||||
rows,
|
||||
now=now,
|
||||
me=run.job.name,
|
||||
crons=crons,
|
||||
latest=last,
|
||||
tz=run.scheduler.tz,
|
||||
boot=BOOT,
|
||||
)
|
||||
_log.info("прогоны: %s", report.note)
|
||||
await _tell(run, report, state, now=now)
|
||||
state.save()
|
||||
|
||||
|
||||
async def _tell(run: JobRun, report: Report, state: Runs, *, now: datetime) -> None:
|
||||
if report.empty:
|
||||
await _spawn(run, EMPTY_BRIEF.format(body=empty_text(report)))
|
||||
state.empty_alerted = now
|
||||
if report.alarms:
|
||||
await _spawn(run, BRIEF.format(body=alarm_text(report), streak=STREAK))
|
||||
for tail in report.alarms:
|
||||
state.alerted[tail.job] = now
|
||||
if report.quiet:
|
||||
await _spawn(run, QUIET_BRIEF.format(body=quiet_text(report)))
|
||||
for quiet in report.quiet:
|
||||
state.quiet[quiet.job] = now
|
||||
if report.clears or report.resumed:
|
||||
await _spawn(run, CLEAR_BRIEF.format(body=clear_text(report)))
|
||||
for clear in report.clears:
|
||||
state.alerted.pop(clear.job, None)
|
||||
for resumed in report.resumed:
|
||||
state.quiet.pop(resumed.job, None)
|
||||
|
||||
|
||||
async def _spawn(run: JobRun, text: str) -> None:
|
||||
await run.spawn_job(agent="beaver-triage", title=TITLE, text=text)
|
||||
@@ -1,56 +0,0 @@
|
||||
"""`POST /hooks/t3code`: событие треда - срочно в разговор, который его запустил."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import TYPE_CHECKING, Any
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from beaver_gateway.jobs.scheduler import JobRun
|
||||
|
||||
QUESTION_HINT = (
|
||||
"Если ответ следует из задания - ответь сам: t3_answer(thread_id, "
|
||||
"{id вопроса: label}). Не знаешь - спроси Бобра через say своими словами, "
|
||||
"потом t3_answer. Тред стоит, пока не ответят."
|
||||
)
|
||||
|
||||
|
||||
async def t3code_event(run: JobRun) -> None:
|
||||
await run.inject_into(
|
||||
run.payload.get("origin"),
|
||||
describe(run.payload),
|
||||
urgency="urgent",
|
||||
origin="t3code",
|
||||
)
|
||||
|
||||
|
||||
def describe(p: dict[str, Any]) -> str:
|
||||
head = (
|
||||
f"t3code: тред «{p.get('title')}» ({p.get('machine')}, {p.get('project')}, "
|
||||
f"thread_id {p.get('thread_id')})"
|
||||
)
|
||||
event = p.get("event")
|
||||
if event in ("question", "approval"):
|
||||
lines = [f"{head} - спрашивает."]
|
||||
for q in (p.get("question") or {}).get("questions", []):
|
||||
multi = " (можно несколько)" if q.get("multi_select") else ""
|
||||
lines.append(
|
||||
f"- [{q['id']}] {q.get('header') or ''}: {q['question']}{multi}"
|
||||
)
|
||||
lines.extend(
|
||||
f" · {o['label']}"
|
||||
+ (f" - {o['description']}" if o.get("description") else "")
|
||||
for o in q.get("options", [])
|
||||
)
|
||||
lines.append(QUESTION_HINT)
|
||||
return "\n".join(lines)
|
||||
if event == "completed":
|
||||
lines = [f"{head} - завершён."]
|
||||
elif event == "interrupted":
|
||||
lines = [f"{head} - прерван."]
|
||||
else:
|
||||
lines = [f"{head} - упал: {p.get('error') or 'без текста ошибки'}."]
|
||||
if p.get("text"):
|
||||
lines.append(f"Ответ треда:\n{p['text']}")
|
||||
if p.get("files"):
|
||||
lines.append("Файлы: " + ", ".join(f["path"] for f in p["files"]))
|
||||
return "\n".join(lines)
|
||||
@@ -1,53 +0,0 @@
|
||||
"""Раз в 10 минут: новое в комнате → триаж → мастер, не чаще раза в час."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from beaver_agent.hands import VIBEGRAM, VIBEGRAM_REPO
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from beaver_gateway.jobs.scheduler import JobRun
|
||||
|
||||
BRIEF = (
|
||||
"Новое в вайбграме (комната {room}, ты там {nick}; остальные - чужие агенты):\n"
|
||||
"{items}\n"
|
||||
'Будить мастера - inject(conversation="master", urgency="wake", '
|
||||
"text=резюме до 3 строк: кто, что, чего ждёт). Мастер прочитает подробности "
|
||||
"через vibegram(read) и ответит через vibegram(send), если решит. "
|
||||
"Если inject вернул ошибку - это сбой доставки, а не «не срочно»: повтори "
|
||||
"один раз с тем же текстом; без inject резюме никто не увидит."
|
||||
)
|
||||
|
||||
_last_wake: datetime | None = None
|
||||
_backlog: list[str] = []
|
||||
|
||||
|
||||
async def vibegram(run: JobRun) -> None:
|
||||
global _last_wake # noqa: PLW0603
|
||||
if VIBEGRAM is None:
|
||||
return
|
||||
events = await VIBEGRAM.pending()
|
||||
_backlog.extend(e.line() for e in events)
|
||||
if not _backlog:
|
||||
return
|
||||
now = datetime.now(UTC)
|
||||
addressed = VIBEGRAM.mentioned(events)
|
||||
if (
|
||||
not addressed
|
||||
and _last_wake is not None
|
||||
and now - _last_wake < timedelta(hours=1)
|
||||
):
|
||||
return
|
||||
_last_wake = now
|
||||
items, _backlog[:] = list(_backlog), []
|
||||
await run.spawn_job(
|
||||
agent="beaver-triage",
|
||||
title="вайбграм",
|
||||
text=BRIEF.format(
|
||||
room=VIBEGRAM_REPO.name,
|
||||
nick=VIBEGRAM.nick,
|
||||
items="\n".join(f"- {item}" for item in items[-40:]),
|
||||
),
|
||||
)
|
||||
@@ -1,14 +0,0 @@
|
||||
"""Раз в ночь: голосовая ветка начинается заново в том же топике."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from beaver_agent.voice import rotate
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from beaver_gateway.jobs.scheduler import JobRun
|
||||
|
||||
|
||||
async def rotate_voice(run: JobRun) -> None:
|
||||
await rotate(run.conversations)
|
||||
@@ -1 +0,0 @@
|
||||
"""Память Бобра в vault: справка, лог реплик, хендауты, вотчер, куратор."""
|
||||
@@ -1,139 +0,0 @@
|
||||
"""Куратор памяти: что нового с прошлого прогона .
|
||||
|
||||
Крон дёргает детерминированный код, модель судит: здесь собирается брифинг
|
||||
для служебного тёрна `beaver-curator` - новые реплики Бобра целиком и имена
|
||||
файлов, изменившихся с прошлого прогона. Время прошлого прогона куратор
|
||||
сам пишет первой строкой `мета/бобер/куратор.md`, запись о прогоне - в файл
|
||||
дня `мета/бобер/куратор/YYYY-MM-DD.md`; нет ничего нового - брифинга нет и
|
||||
джоб не спавнится.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from dataclasses import dataclass
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from typing import TYPE_CHECKING
|
||||
from zoneinfo import ZoneInfo
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from pathlib import Path
|
||||
|
||||
LAST_RUN_RE = re.compile(r"^последний прогон:\s*(\S+)")
|
||||
REPLY_RE = re.compile(r"^- (\d{4}-\d{2}-\d{2} \d{2}:\d{2}) · ")
|
||||
MAX_REPLY_CHARS = 60_000
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Watched:
|
||||
label: str
|
||||
root: Path
|
||||
pattern: str = "**/*.md"
|
||||
|
||||
|
||||
def last_run(journal: Path, *, default: datetime) -> datetime:
|
||||
"""`последний прогон: <ISO>` из начала журнала, иначе ``default``."""
|
||||
if not journal.exists():
|
||||
return default
|
||||
for line in journal.read_text(encoding="utf-8", errors="ignore").splitlines()[:5]:
|
||||
m = LAST_RUN_RE.match(line.strip())
|
||||
if m:
|
||||
try:
|
||||
stamp = datetime.fromisoformat(m.group(1))
|
||||
except ValueError:
|
||||
return default
|
||||
return stamp if stamp.tzinfo else stamp.replace(tzinfo=UTC)
|
||||
return default
|
||||
|
||||
|
||||
def new_replies(replies_dir: Path, since: datetime, tz: str) -> list[str]:
|
||||
"""Строки `реплики/YYYY-MM-DD.md` позже ``since`` (время в строках локальное)."""
|
||||
zone = ZoneInfo(tz)
|
||||
local_since = since.astimezone(zone).replace(tzinfo=None)
|
||||
out: list[str] = []
|
||||
if not replies_dir.exists():
|
||||
return out
|
||||
first = f"{local_since:%Y-%m-%d}.md"
|
||||
for path in sorted(replies_dir.glob("????-??-??.md")):
|
||||
if path.name < first:
|
||||
continue
|
||||
for line in path.read_text(encoding="utf-8", errors="ignore").splitlines():
|
||||
m = REPLY_RE.match(line)
|
||||
if not m:
|
||||
continue
|
||||
try:
|
||||
at = datetime.strptime(m.group(1), "%Y-%m-%d %H:%M") # noqa: DTZ007
|
||||
except ValueError:
|
||||
continue
|
||||
if at > local_since:
|
||||
out.append(line)
|
||||
return out
|
||||
|
||||
|
||||
def changed_files(
|
||||
watched: list[Watched], since: datetime, vault: Path, *, skip: tuple[str, ...] = ()
|
||||
) -> list[str]:
|
||||
"""`путь (размер)` для файлов с mtime позже ``since``; ``skip`` - подстроки."""
|
||||
out: list[tuple[str, str]] = []
|
||||
stamp = since.timestamp()
|
||||
for w in watched:
|
||||
if not w.root.exists():
|
||||
continue
|
||||
for path in w.root.glob(w.pattern):
|
||||
if not path.is_file() or path.name.startswith("."):
|
||||
continue
|
||||
rel = str(path.relative_to(vault))
|
||||
if any(s in rel for s in skip):
|
||||
continue
|
||||
if path.stat().st_mtime > stamp:
|
||||
out.append((w.label, f"`{rel}` ({path.stat().st_size // 1024} КБ)"))
|
||||
out.sort()
|
||||
return [f"{label}: {desc}" for label, desc in out]
|
||||
|
||||
|
||||
def briefing(
|
||||
*,
|
||||
vault: Path,
|
||||
journal: Path,
|
||||
runs: Path,
|
||||
replies_dir: Path,
|
||||
watched: list[Watched],
|
||||
tz: str,
|
||||
now: datetime | None = None,
|
||||
default_window: timedelta = timedelta(hours=24),
|
||||
skip: tuple[Path, ...] = (),
|
||||
) -> str | None:
|
||||
"""Первое сообщение куратору или ``None``, если с прошлого прогона ничего нет."""
|
||||
now = now or datetime.now(UTC)
|
||||
since = last_run(journal, default=now - default_window)
|
||||
replies = new_replies(replies_dir, since, tz)
|
||||
changed = changed_files(
|
||||
watched,
|
||||
since,
|
||||
vault,
|
||||
skip=tuple(str(p.relative_to(vault)) for p in (journal, *skip)),
|
||||
)
|
||||
if not replies and not changed:
|
||||
return None
|
||||
zone = ZoneInfo(tz)
|
||||
local = now.astimezone(zone)
|
||||
head = (
|
||||
f"Прогон куратора {local:%Y-%m-%d %H:%M} ({tz}); прошлый - "
|
||||
f"{since.astimezone(zone):%Y-%m-%d %H:%M}. Ниже - что изменилось с тех пор; "
|
||||
"остальное читай сам по слоям. В конце запись о прогоне - в "
|
||||
f"`{(runs / f'{local:%Y-%m-%d}.md').relative_to(vault)}`, а в "
|
||||
f"`{journal.relative_to(vault)}` только первая строка: `последний прогон: "
|
||||
f"{local.isoformat(timespec='seconds')}`."
|
||||
)
|
||||
parts = [head]
|
||||
if replies:
|
||||
text = "\n".join(replies)
|
||||
if len(text) > MAX_REPLY_CHARS:
|
||||
text = text[-MAX_REPLY_CHARS:]
|
||||
text = "…(обрезано, начало - в файле)\n" + text[text.find("\n") + 1 :]
|
||||
parts.append(f"Новые реплики Бобра ({len(replies)}):\n{text}")
|
||||
else:
|
||||
parts.append("Новых реплик Бобра нет.")
|
||||
if changed:
|
||||
parts.append("Изменились файлы:\n" + "\n".join(f"- {c}" for c in changed[:80]))
|
||||
return "\n\n".join(parts)
|
||||
@@ -1,182 +0,0 @@
|
||||
"""Смена мастера и закрытие чата: утренний сид, хендаут, «новый день», дистиллятор."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import time
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from beaver_gateway.frontends.turn_record import slugify
|
||||
|
||||
from beaver_agent.memory.recall import notes_head
|
||||
from beaver_agent.vault import (
|
||||
DAYS,
|
||||
DIARY,
|
||||
DIGESTS,
|
||||
GRANULES,
|
||||
PORTRAIT,
|
||||
STATE,
|
||||
VAULT,
|
||||
ZONE,
|
||||
read,
|
||||
)
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from beaver_gateway.conversations.distill import DistillContext
|
||||
from beaver_gateway.conversations.rotation import HandoutContext
|
||||
from beaver_gateway.conversations.texts import NewDayContext, SeedContext
|
||||
|
||||
|
||||
def latest_handout() -> Path | None:
|
||||
"""Последний хендаут, а не «вчерашний по календарю»."""
|
||||
files = sorted(DAYS.glob("????-??-??.md")) if DAYS.exists() else []
|
||||
return files[-1] if files else None
|
||||
|
||||
|
||||
PROC_INIT = Path("/proc/1")
|
||||
"""mtime PID 1 - момент старта контейнера, проверено в бою."""
|
||||
PACKAGE = Path(__file__).resolve().parent.parent
|
||||
"""Корень пакета: свежесть кода меряем от себя, а не от пути в контейнере."""
|
||||
|
||||
DEPLOY_MARK = "Выкат: процесс поднят {start} ({ago}), свежесть кода {code} - {verdict}."
|
||||
CODE_OLDER = "код старше старта, значит крутится то, что выкатывали"
|
||||
CODE_NEWER = "код НОВЕЕ старта: правка на диске есть, рестарта после неё не было"
|
||||
SAME_MINUTE = "выкат и правка в одну минуту"
|
||||
HOUR = 3600
|
||||
|
||||
|
||||
def _ago(seconds: float) -> str:
|
||||
"""Целыми часами, а меньше часа - минутами."""
|
||||
if seconds < HOUR:
|
||||
return f"{int(seconds // 60)} мин назад"
|
||||
return f"{int(seconds // HOUR)} ч назад"
|
||||
|
||||
|
||||
def _clock(stamp: float) -> str:
|
||||
return f"{datetime.fromtimestamp(stamp, ZONE):%Y-%m-%d %H:%M}"
|
||||
|
||||
|
||||
def deploy_mark(proc: Path = PROC_INIT, package: Path = PACKAGE) -> str | None:
|
||||
"""Когда подняли процесс и насколько свеж код, который в нём крутится.
|
||||
|
||||
Две цифры рядом: mtime PID 1 - старт контейнера, последний изменённый
|
||||
`*.py` пакета - свежесть исходников. Порознь каждая врёт: код бывает
|
||||
новее старта, и тогда правка на диске есть, а рестарта после неё не было.
|
||||
Любая осечка (нет `/proc`, нет прав, пустой пакет) - None: сид не имеет
|
||||
права упасть из-за этой отметки.
|
||||
"""
|
||||
try:
|
||||
started = proc.stat().st_mtime
|
||||
sources = [
|
||||
path.stat().st_mtime
|
||||
for path in package.rglob("*.py")
|
||||
if "__pycache__" not in path.parts
|
||||
]
|
||||
if not sources:
|
||||
return None
|
||||
code = max(sources)
|
||||
gap = code - started
|
||||
if abs(gap) < 60:
|
||||
verdict = SAME_MINUTE
|
||||
elif gap > 0:
|
||||
verdict = CODE_NEWER
|
||||
else:
|
||||
verdict = CODE_OLDER
|
||||
return DEPLOY_MARK.format(
|
||||
start=_clock(started),
|
||||
ago=_ago(time.time() - started),
|
||||
code=_clock(code),
|
||||
verdict=verdict,
|
||||
)
|
||||
except (OSError, ValueError):
|
||||
return None
|
||||
|
||||
|
||||
def seed_body(ctx: SeedContext) -> str | None:
|
||||
"""Утренний сид: хендаут, шапка состояния, портрет Бобра, отметка о выкате."""
|
||||
if ctx.seed != "morning":
|
||||
return None
|
||||
handout = latest_handout()
|
||||
if handout is None:
|
||||
return "Хендаут не приехал."
|
||||
parts = [
|
||||
f"Хендаут ({handout.stem}):\n\n{handout.read_text(encoding='utf-8').strip()}"
|
||||
]
|
||||
signal = "\n".join((read(STATE) or "").splitlines()[:5])
|
||||
if signal:
|
||||
parts.append(
|
||||
f"Состояние (первые строки, полностью в {STATE.relative_to(VAULT)}):\n"
|
||||
f"{signal}"
|
||||
)
|
||||
portrait = notes_head(PORTRAIT, ("сейчас", "паттерны"), cap=40)
|
||||
if portrait:
|
||||
parts.append(
|
||||
"Портрет Бобра (шапка "
|
||||
f"`{PORTRAIT.relative_to(VAULT)}`, лента - там же):\n{portrait}"
|
||||
)
|
||||
mark = deploy_mark()
|
||||
if mark:
|
||||
parts.append(mark)
|
||||
return "\n\n".join(parts)
|
||||
|
||||
|
||||
DEFAULT_HANDOUT = (
|
||||
"Этот мастер закрывается ({reason}). Напиши хендаут за {day} в "
|
||||
"`мета/бобер/дни/{day}.md`: справку на утро, не задание."
|
||||
)
|
||||
|
||||
|
||||
def handout_prompt(ctx: HandoutContext) -> str:
|
||||
day = ctx.day.isoformat()
|
||||
body = (
|
||||
(read(GRANULES / "хендаут.md") or DEFAULT_HANDOUT)
|
||||
.replace("{day}", day)
|
||||
.replace("{reason}", ctx.reason)
|
||||
)
|
||||
if (DIARY / f"{day}.md").exists():
|
||||
return f"{body}\n\nДневник за {day} приехал: `📅 дни/{day}.md`, возьми из него."
|
||||
return f"{body}\n\nДневник за {day} не приехал - так и напиши в разделе «дневник»."
|
||||
|
||||
|
||||
NEW_DAY = (
|
||||
"Новый день ({day}). Ты - новый мастер того же треда: хендаут и сигнал состояния "
|
||||
"в сиде выше. Скажи Бобру что-то через say, только если есть что сказать."
|
||||
)
|
||||
SAME_DAY = (
|
||||
"Мастер пересоздан ({why}), день тот же - {day}. Хендаут в сиде выше - справка от "
|
||||
"предыдущего мастера за сегодня, не утро: продолжай с того места, ничего не "
|
||||
"приветствуй. Скажи Бобру что-то через say, только если есть что сказать."
|
||||
)
|
||||
ROTATION_WHY = {
|
||||
"age": "прошло больше 36 часов",
|
||||
"context": "контекст стал слишком большим",
|
||||
"manual": "Бобёр запустил ротацию руками",
|
||||
}
|
||||
|
||||
|
||||
def new_day(ctx: NewDayContext) -> str:
|
||||
"""«Новый день» - только ночная ротация; остальные причины - тот же день."""
|
||||
day = ctx.day.isoformat()
|
||||
if ctx.reason == "night":
|
||||
return NEW_DAY.format(day=day)
|
||||
return SAME_DAY.format(day=day, why=ROTATION_WHY.get(ctx.reason, ctx.reason))
|
||||
|
||||
|
||||
DISTILL = (
|
||||
"Глубокий чат [[{chat}]] закрыт ({reason}), сегодня {day}. Выжимка - `Write` в "
|
||||
'`{path}`, фронтматтер `source: "[[{chat}]]"`, `date: {day}`; слив - текст '
|
||||
"ответа, до 5 строк, третье лицо."
|
||||
)
|
||||
DISTILL_NO_MEMORY = (
|
||||
"Глубокий чат [[{chat}]] закрыт ({reason}), сегодня {day}. Память для него "
|
||||
"выключена: файл не пиши, только слив текстом ответа - до 5 строк, третье лицо."
|
||||
)
|
||||
|
||||
|
||||
def distill_prompt(ctx: DistillContext) -> str:
|
||||
day = ctx.day.isoformat()
|
||||
if not ctx.memory:
|
||||
return DISTILL_NO_MEMORY.format(chat=ctx.chat_name, reason=ctx.reason, day=day)
|
||||
path = DIGESTS / f"{day} - {slugify(ctx.chat_name, maxlen=60)}.md"
|
||||
return DISTILL.format(chat=ctx.chat_name, reason=ctx.reason, day=day, path=path)
|
||||
@@ -1,429 +0,0 @@
|
||||
"""Справка под сообщением Бобра и лог его реплик .
|
||||
|
||||
Gateway путей не знает; здесь - что искать по тексту сообщения и куда писать
|
||||
сказанное. ``Recall.block`` отдаёт указатели, не выводы: карточка упомянутого
|
||||
человека, его записки о нём (`мета/бобер/наблюдения/<имя> - наблюдения.md`),
|
||||
дни дневника, где он встречался, и раз в день - подошедшие сроки из досок и
|
||||
ближайшая неделя календарей.
|
||||
``ReplyLog.write`` кладёт каждую реплику Бобра из мастера и веток в
|
||||
`мета/бобер/реплики/YYYY-MM-DD.md` - единственное место, где они grep-абельны:
|
||||
транскрипт живёт в Postgres, а глубокие чаты и так лежат файлами в `💬 чаты/`.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
import re
|
||||
import time
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import date, timedelta
|
||||
from typing import TYPE_CHECKING
|
||||
from zoneinfo import ZoneInfo
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
|
||||
from beaver_gateway.conversations.envelope import RecallContext
|
||||
from beaver_gateway.conversations.texts import UserSaid
|
||||
|
||||
from beaver_agent.hands.calendars import Calendars, Event, Upcoming
|
||||
|
||||
_log = logging.getLogger(__name__)
|
||||
|
||||
LABEL = "справка (указатели по сообщению, не выводы; открой, если относится к вопросу):"
|
||||
VOWELS = "аеёиоуыэюя"
|
||||
KINDS = {"master": "мастер", "branch": "ветка"}
|
||||
CALENDAR = "🗓 календарь"
|
||||
CALENDAR_LIMIT = 40
|
||||
"""Предохранитель на разовые события; повседневные повторы под него не идут."""
|
||||
CALENDAR_NAMES = 5
|
||||
"""Сколько названий показывать в свёрнутой строке повседневных повторов."""
|
||||
CALENDAR_ERROR_MAX = 90
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Person:
|
||||
name: str
|
||||
"""Имя файла карточки без `.md`; записки - `<имя> - наблюдения.md`."""
|
||||
aliases: tuple[str, ...]
|
||||
path: str
|
||||
"""Путь карточки от корня vault."""
|
||||
plain: bool
|
||||
"""Искать по голому имени в тексте (ближний круг), а не только по `[[ссылке]]`."""
|
||||
|
||||
@property
|
||||
def keys(self) -> tuple[str, ...]:
|
||||
return (self.name, *self.aliases)
|
||||
|
||||
|
||||
def frontmatter_aliases(text: str) -> tuple[str, ...]:
|
||||
"""`aliases:` из фронтматтера карточки - список строк или пусто."""
|
||||
if not text.startswith("---"):
|
||||
return ()
|
||||
end = text.find("\n---", 3)
|
||||
if end < 0:
|
||||
return ()
|
||||
out: list[str] = []
|
||||
inside = False
|
||||
for line in text[3:end].splitlines():
|
||||
if line.startswith("aliases:"):
|
||||
inside = True
|
||||
rest = line[len("aliases:") :].strip()
|
||||
if rest and rest != "[]":
|
||||
out += [a.strip().strip("\"'") for a in rest.strip("[]").split(",")]
|
||||
continue
|
||||
if inside:
|
||||
stripped = line.strip()
|
||||
if stripped.startswith("- "):
|
||||
out.append(stripped[2:].strip().strip("\"'"))
|
||||
continue
|
||||
if stripped:
|
||||
inside = False
|
||||
return tuple(a for a in out if a)
|
||||
|
||||
|
||||
class People:
|
||||
"""Индекс карточек `👤 люди/`: имя, алиасы, путь; пересобирается раз в `ttl`."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
root: Path,
|
||||
vault: Path,
|
||||
*,
|
||||
plain_dirs: tuple[str, ...] = ("личное", "профессиональное"),
|
||||
skip_dirs: tuple[str, ...] = ("архив", "рандомы", "группы"),
|
||||
ttl: float = 600.0,
|
||||
) -> None:
|
||||
self._root = root
|
||||
self._vault = vault
|
||||
self._plain_dirs = plain_dirs
|
||||
self._skip_dirs = skip_dirs
|
||||
self._ttl = ttl
|
||||
self._built = 0.0
|
||||
self._people: list[Person] = []
|
||||
|
||||
def all(self) -> list[Person]:
|
||||
if time.monotonic() - self._built > self._ttl:
|
||||
self._people = self._scan()
|
||||
self._built = time.monotonic()
|
||||
return self._people
|
||||
|
||||
def _scan(self) -> list[Person]:
|
||||
if not self._root.exists():
|
||||
return []
|
||||
out: list[Person] = []
|
||||
for card in sorted(self._root.rglob("*.md")):
|
||||
parts = card.relative_to(self._root).parts[:-1]
|
||||
plain = bool(parts) and parts[0] in self._plain_dirs
|
||||
plain = plain and not any(p in self._skip_dirs for p in parts)
|
||||
try:
|
||||
head = card.read_text(encoding="utf-8", errors="ignore")[:2000]
|
||||
except OSError:
|
||||
continue
|
||||
out.append(
|
||||
Person(
|
||||
name=card.stem,
|
||||
aliases=frontmatter_aliases(head),
|
||||
path=str(card.relative_to(self._vault)),
|
||||
plain=plain,
|
||||
)
|
||||
)
|
||||
return out
|
||||
|
||||
|
||||
def _stem_pattern(key: str) -> re.Pattern[str]:
|
||||
"""Имя с падежом: `Зина` → Зина/Зине/Зину/Зиной, `Прохор` → Прохора/Прохором."""
|
||||
stem = key[:-1] if key[-1].lower() in VOWELS and len(key) > 3 else key
|
||||
return re.compile(rf"(?<!\w){re.escape(stem)}\w{{0,2}}(?!\w)", re.IGNORECASE)
|
||||
|
||||
|
||||
def mentions(text: str, people: list[Person], *, limit: int = 3) -> list[Person]:
|
||||
"""Кто упомянут: `[[ссылкой]]` - любой, голым именем - только ближний круг."""
|
||||
found: dict[str, int] = {}
|
||||
by_key = {k.casefold(): p for p in people for k in p.keys}
|
||||
for m in re.finditer(r"\[\[([^\]|#]+)", text):
|
||||
target = m.group(1).strip().split("/")[-1].casefold()
|
||||
target = target.removesuffix(".md")
|
||||
person = by_key.get(target)
|
||||
if person is not None:
|
||||
found.setdefault(person.name, m.start())
|
||||
for person in people:
|
||||
if not person.plain or person.name in found:
|
||||
continue
|
||||
for key in person.keys:
|
||||
if " " in key:
|
||||
m = re.search(rf"(?<!\w){re.escape(key)}(?!\w)", text, re.IGNORECASE)
|
||||
elif len(key) >= 4:
|
||||
m = _stem_pattern(key).search(text)
|
||||
else:
|
||||
continue
|
||||
if m:
|
||||
found.setdefault(person.name, m.start())
|
||||
break
|
||||
order = sorted(found.items(), key=lambda kv: kv[1])[:limit]
|
||||
by_name = {p.name: p for p in people}
|
||||
return [by_name[name] for name, _ in order]
|
||||
|
||||
|
||||
def notes_sections(path: Path) -> dict[str, list[str]]:
|
||||
"""`## заголовок` → непустые строки под ним (до следующего `## `)."""
|
||||
out: dict[str, list[str]] = {}
|
||||
current: str | None = None
|
||||
for raw in path.read_text(encoding="utf-8", errors="ignore").splitlines():
|
||||
line = raw.rstrip()
|
||||
if line.startswith("## "):
|
||||
current = line[3:].strip().lower()
|
||||
out.setdefault(current, [])
|
||||
continue
|
||||
if current is not None and line.strip():
|
||||
out[current].append(line.strip())
|
||||
return out
|
||||
|
||||
|
||||
def notes_head(path: Path, sections: tuple[str, ...], *, cap: int = 40) -> str | None:
|
||||
"""Выбранные секции файла записок одним блоком - для сида (портрет Бобра)."""
|
||||
if not path.exists():
|
||||
return None
|
||||
parsed = notes_sections(path)
|
||||
lines: list[str] = []
|
||||
for name in sections:
|
||||
body = parsed.get(name, [])
|
||||
if body:
|
||||
lines.append(f"## {name}")
|
||||
lines.extend(body)
|
||||
if not lines:
|
||||
return None
|
||||
if len(lines) > cap:
|
||||
lines = [*lines[:cap], f"… ещё {len(lines) - cap} строк в файле"]
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
@dataclass
|
||||
class Recall:
|
||||
"""Справка по сообщению: указатели в vault, которые gateway не может знать."""
|
||||
|
||||
vault: Path
|
||||
people_dir: Path
|
||||
notes_dir: Path
|
||||
diary_dir: Path
|
||||
boards_dir: Path
|
||||
tz: str = "Europe/Warsaw"
|
||||
diary_scan: int = 400
|
||||
"""Сколько последних дней дневника просматривать на упоминания."""
|
||||
mute: frozenset[str] = frozenset()
|
||||
"""Агенты, которым справку не показывают: чужие люди, чужие уши."""
|
||||
calendar: Calendars | None = None
|
||||
"""Ical-фиды календарей; None - календари не настроены, секции нет вовсе."""
|
||||
_people: People | None = field(default=None, init=False, repr=False)
|
||||
_diary_cache: dict[str, tuple[float, list[str]]] = field(
|
||||
default_factory=dict, init=False, repr=False
|
||||
)
|
||||
_deadlines_day: date | None = field(default=None, init=False, repr=False)
|
||||
_calendar_day: date | None = field(default=None, init=False, repr=False)
|
||||
|
||||
@property
|
||||
def people(self) -> People:
|
||||
if self._people is None:
|
||||
self._people = People(self.people_dir, self.vault)
|
||||
return self._people
|
||||
|
||||
def block(self, ctx: RecallContext) -> str | None:
|
||||
if ctx.agent in self.mute:
|
||||
return None
|
||||
today = ctx.now.astimezone(ZoneInfo(self.tz)).date()
|
||||
lines = [self.person_line(p) for p in mentions(ctx.text, self.people.all())]
|
||||
if ctx.kind == "master":
|
||||
lines += self.deadlines(today)
|
||||
lines += self.calendar_lines(ctx.now, today)
|
||||
if not lines:
|
||||
return None
|
||||
return "\n".join([LABEL, *lines])
|
||||
|
||||
def person_line(self, person: Person, *, now_lines: int = 6) -> str:
|
||||
"""Указатели по человеку и `## сейчас` из его записок - инлайн."""
|
||||
parts = [f"👤 {person.name} - карточка `{person.path}`"]
|
||||
notes = self.notes_dir / f"{person.name} - наблюдения.md"
|
||||
rel = notes.relative_to(self.vault)
|
||||
now: list[str] = []
|
||||
if notes.exists():
|
||||
sections = notes_sections(notes)
|
||||
feed = sections.get("лента", [])
|
||||
now = [ln for ln in sections.get("сейчас", []) if ln.startswith("- ")]
|
||||
patterns = [
|
||||
ln for ln in sections.get("паттерны", []) if ln.startswith("- ")
|
||||
]
|
||||
desc = f"записки `{rel}`: лента {len(feed)} стр."
|
||||
if patterns:
|
||||
desc += f", паттернов {len(patterns)}"
|
||||
if not now and feed:
|
||||
last = feed[-1][2:]
|
||||
desc += ", последняя: " + (
|
||||
last if len(last) <= 110 else last[:109] + "…"
|
||||
)
|
||||
parts.append(desc)
|
||||
else:
|
||||
parts.append(f"записок нет (`{rel}`)")
|
||||
days = self.diary_hits(person)
|
||||
if days:
|
||||
parts.append("дневник: " + ", ".join(f"[[{d}]]" for d in days))
|
||||
line = "; ".join(parts)
|
||||
if now:
|
||||
line += "; сейчас:\n" + "\n".join(f" {ln}" for ln in now[:now_lines])
|
||||
return line
|
||||
|
||||
def diary_hits(
|
||||
self, person: Person, *, limit: int = 3, ttl: float = 600.0
|
||||
) -> list[str]:
|
||||
cached = self._diary_cache.get(person.name)
|
||||
if cached and time.monotonic() - cached[0] < ttl:
|
||||
return cached[1]
|
||||
keys = [f"[[{k.casefold()}" for k in person.keys]
|
||||
hits: list[str] = []
|
||||
files = sorted(self.diary_dir.glob("????-??-??.md"), reverse=True)
|
||||
for path in files[: self.diary_scan]:
|
||||
try:
|
||||
text = path.read_text(encoding="utf-8", errors="ignore").casefold()
|
||||
except OSError:
|
||||
continue
|
||||
if any(k in text for k in keys):
|
||||
hits.append(path.stem)
|
||||
if len(hits) >= limit:
|
||||
break
|
||||
self._diary_cache[person.name] = (time.monotonic(), hits)
|
||||
return hits
|
||||
|
||||
def deadlines(
|
||||
self, today: date, *, horizon_days: int = 1, limit: int = 8
|
||||
) -> list[str]:
|
||||
"""Открытые задачи досок с 📅 не позже завтра - раз в день, первым конвертом."""
|
||||
if self._deadlines_day == today:
|
||||
return []
|
||||
self._deadlines_day = today
|
||||
found: list[tuple[date, str, str]] = []
|
||||
for board in (
|
||||
sorted(self.boards_dir.glob("*.md")) if self.boards_dir.exists() else []
|
||||
):
|
||||
live = board.read_text(encoding="utf-8", errors="ignore").split("\n***", 1)[
|
||||
0
|
||||
]
|
||||
for m in re.finditer(
|
||||
r"^\s*- \[ \] (.+?)\s*📅 (\d{4}-\d{2}-\d{2})", live, re.MULTILINE
|
||||
):
|
||||
try:
|
||||
due = date.fromisoformat(m.group(2))
|
||||
except ValueError:
|
||||
continue
|
||||
if due <= today + timedelta(days=horizon_days):
|
||||
found.append((due, board.stem, m.group(1).strip()))
|
||||
found.sort()
|
||||
return [f"📆 {due:%m-%d} {board}: {task}" for due, board, task in found[:limit]]
|
||||
|
||||
def calendar_lines(self, now: datetime, today: date) -> list[str]:
|
||||
"""Ближайшая неделя календарей - раз в день, следом за сроками досок.
|
||||
|
||||
Секция печатается всегда, когда до неё дошло: пустое окно - строкой
|
||||
«событий нет», упавший фид - строкой «ОШИБКА» и записью в лог. Молча
|
||||
пропасть она не может, иначе отказ канала неотличим от спокойного
|
||||
календаря - так однажды и пролежала незамеченной сессия в USOS.
|
||||
"""
|
||||
if self.calendar is None or self._calendar_day == today:
|
||||
return []
|
||||
self._calendar_day = today
|
||||
try:
|
||||
found = self.calendar.upcoming(now)
|
||||
except Exception as exc: # noqa: BLE001
|
||||
_log.exception("календарь: справка не собралась")
|
||||
reason = " ".join(f"{type(exc).__name__}: {exc}".split())
|
||||
return [f"{CALENDAR}: ОШИБКА {reason[:CALENDAR_ERROR_MAX]}"]
|
||||
lines = [f"{CALENDAR}: ОШИБКА {reason}" for reason in found.errors]
|
||||
if found.read:
|
||||
lines += self.calendar_window(found, self.calendar.days)
|
||||
return lines or [f"{CALENDAR}: ОШИБКА фиды не ответили"]
|
||||
|
||||
def calendar_window(self, found: Upcoming, days: int) -> list[str]:
|
||||
"""Окно ответивших фидов: разовые событиями, повседневный быт - одной строкой.
|
||||
|
||||
Разовых за неделю физически мало, и ровно они и есть сигнал: экзамен,
|
||||
встреча, приём. Их видно целиком; лимит тут - предохранитель от абсурда,
|
||||
а не способ уместиться. Ежедневные повторы считаются и называются, но
|
||||
своими строками разовые не вытесняют - иначе секция выглядит здоровой и
|
||||
при этом показывает двое суток вместо недели.
|
||||
"""
|
||||
stamp = f"{found.at:%Y-%m-%d %H:%M}"
|
||||
if not found.events:
|
||||
return [f"{CALENDAR} ({days} дней): событий нет, данные на {stamp}"]
|
||||
zone = ZoneInfo(self.tz)
|
||||
singles = [event for event in found.events if not event.routine]
|
||||
routine = [event for event in found.events if event.routine]
|
||||
shown = singles[:CALENDAR_LIMIT]
|
||||
head = (
|
||||
f"{CALENDAR} ({days} дней), разовых {len(singles)}, "
|
||||
f"повседневных {len(routine)}, данные на {stamp}:"
|
||||
)
|
||||
lines = [head]
|
||||
lines += [f" - {event_line(event, zone)}" for event in shown]
|
||||
if len(singles) > len(shown):
|
||||
lines.append(f" … и ещё {len(singles) - len(shown)} разовых в окне")
|
||||
if routine:
|
||||
lines.append(
|
||||
f" - повседневных повторов: {len(routine)} ({routine_names(routine)})"
|
||||
)
|
||||
return lines
|
||||
|
||||
|
||||
def routine_names(events: list[Event], *, limit: int = CALENDAR_NAMES) -> str:
|
||||
"""Уникальные названия бытовых повторов по первому появлению, до `limit`."""
|
||||
names = list(dict.fromkeys(event.title for event in events))
|
||||
return ", ".join(names[:limit]) + (" и др." if len(names) > limit else "")
|
||||
|
||||
|
||||
def event_line(event: Event, zone: ZoneInfo) -> str:
|
||||
"""Дата, начало, название и место - одной строкой в зоне агента."""
|
||||
start = event.start.astimezone(zone)
|
||||
when = "весь день" if event.all_day else f"{start:%H:%M}"
|
||||
place = f" · {event.place}" if event.place else ""
|
||||
return f"{start:%m-%d} {when} {event.title}{place}"
|
||||
|
||||
|
||||
@dataclass
|
||||
class ReplyLog:
|
||||
"""`мета/бобер/реплики/YYYY-MM-DD.md`: строка на реплику из мастера и веток."""
|
||||
|
||||
dir: Path
|
||||
tz: str = "Europe/Warsaw"
|
||||
max_chars: int = 600
|
||||
mute: frozenset[str] = frozenset()
|
||||
"""Агенты, чьи разговоры в лог реплик не идут."""
|
||||
|
||||
def write(self, said: UserSaid) -> None:
|
||||
if said.agent in self.mute:
|
||||
return
|
||||
text = said.text
|
||||
seeded = text.startswith("[сид:")
|
||||
if seeded:
|
||||
# спавн ветки с текстом: строка сида едет над самим сообщением
|
||||
text = text.split("\n\n", 1)[1] if "\n\n" in text else ""
|
||||
flat = " ⏎ ".join(ln.strip() for ln in text.strip().splitlines() if ln.strip())
|
||||
if not flat:
|
||||
return
|
||||
if len(flat) > self.max_chars:
|
||||
flat = flat[: self.max_chars - 1] + "…"
|
||||
local = said.at.astimezone(ZoneInfo(self.tz))
|
||||
where = KINDS.get(said.kind, said.kind)
|
||||
if said.kind != "master" and said.title:
|
||||
where = f"{where} «{said.title}»"
|
||||
if seeded:
|
||||
# не человек сказал, а механизм спавна: видно по источнику, не по тексту
|
||||
where = f"{where} (бриф)"
|
||||
path = self.dir / f"{local:%Y-%m-%d}.md"
|
||||
self.dir.mkdir(parents=True, exist_ok=True)
|
||||
if not path.exists():
|
||||
path.write_text(
|
||||
f"# реплики Бобра, {local:%Y-%m-%d}\n\n"
|
||||
"> пишет gateway: что Бобёр сказал в мастере и ветках, "
|
||||
"строка на сообщение. Глубокие чаты лежат в `💬 чаты/` сами.\n\n",
|
||||
encoding="utf-8",
|
||||
)
|
||||
with path.open("a", encoding="utf-8") as fh:
|
||||
fh.write(f"- {local:%Y-%m-%d %H:%M} · {where} · {flat}\n")
|
||||
@@ -1,71 +0,0 @@
|
||||
"""Что из vault попадает в конверт и за чем следит куратор."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from beaver_gateway.vault.watch import VaultWatch, WatchRules
|
||||
|
||||
from beaver_agent.hands import CALENDARS
|
||||
from beaver_agent.memory.curator import Watched
|
||||
from beaver_agent.memory.recall import Recall, ReplyLog
|
||||
from beaver_agent.vault import (
|
||||
BEAVER,
|
||||
BOARDS,
|
||||
DAYS,
|
||||
DIARY,
|
||||
DIGESTS,
|
||||
NOTES,
|
||||
PEOPLE,
|
||||
REPLIES,
|
||||
TZ,
|
||||
VAULT,
|
||||
)
|
||||
from beaver_agent.voice import AGENT as VOICE
|
||||
|
||||
watch = VaultWatch(
|
||||
VAULT,
|
||||
WatchRules(
|
||||
full=("📅 дни/{today}.md",),
|
||||
names=(
|
||||
"📅 дни/**",
|
||||
"👤 люди/**",
|
||||
"📆 планирование/**",
|
||||
"📆 доски/**",
|
||||
"💻 проекты/**",
|
||||
"🧠 мысли/**",
|
||||
"📶 ресерчи/**",
|
||||
"мета/бобер/**",
|
||||
),
|
||||
ignore=(
|
||||
"💬 чаты/**",
|
||||
"мета/**",
|
||||
"мета/бобер/реплики/**",
|
||||
"**/attachments/**",
|
||||
".obsidian/**",
|
||||
),
|
||||
),
|
||||
tz=TZ,
|
||||
)
|
||||
"""Дневник за сегодня - строками, остальное именами; конкретный паттерн побеждает."""
|
||||
|
||||
recall = Recall(
|
||||
vault=VAULT,
|
||||
people_dir=PEOPLE,
|
||||
notes_dir=NOTES,
|
||||
diary_dir=DIARY,
|
||||
boards_dir=BOARDS,
|
||||
tz=TZ,
|
||||
mute=frozenset({VOICE}),
|
||||
calendar=CALENDARS,
|
||||
)
|
||||
"""Голосовому агенту справки нет: за колонкой может стоять кто угодно."""
|
||||
|
||||
replies = ReplyLog(REPLIES, tz=TZ, mute=frozenset({VOICE}))
|
||||
|
||||
CURATOR_WATCH = [
|
||||
Watched("хендауты", DAYS, "????-??-??.md"),
|
||||
Watched("выжимки", DIGESTS, "*.md"),
|
||||
Watched("наблюдения", NOTES, "*.md"),
|
||||
Watched("состояние", BEAVER, "состояние.md"),
|
||||
Watched("дневник", DIARY, "????-??-??.md"),
|
||||
Watched("карточки", PEOPLE, "**/*.md"),
|
||||
]
|
||||
@@ -1,294 +0,0 @@
|
||||
"""Граница без permission-промптов: правила PreToolUse и зоны vault.
|
||||
|
||||
Модель везде в `bypassPermissions`; что ей можно, решают `disallowed_tools`
|
||||
и правила отсюда. Правило получает `ToolCall` и возвращает `Deny` с
|
||||
причиной, которую модель читает как результат тулзы, или `None`.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import fnmatch
|
||||
import shlex
|
||||
from dataclasses import dataclass
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from beaver_gateway.agents.policy import Deny, PolicyRule, ToolCall
|
||||
|
||||
from beaver_agent.vault import BEAVER, CHATS, VAULT
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from collections.abc import Iterator
|
||||
from pathlib import Path
|
||||
|
||||
__all__ = [
|
||||
"DEEP_DISALLOWED",
|
||||
"DISPATCHER_DISALLOWED",
|
||||
"DISTILLER_DISALLOWED",
|
||||
"STRICT_ZONES",
|
||||
"TRIAGE_DISALLOWED",
|
||||
"VAULT_POLICY",
|
||||
"ZONES",
|
||||
"Zones",
|
||||
"bash_zones",
|
||||
"forbid_skills",
|
||||
"requires_skill",
|
||||
"skill_tracker",
|
||||
"vault_zones",
|
||||
]
|
||||
|
||||
DISPATCHER_DISALLOWED = ("ExitPlanMode", "EnterPlanMode", "NotebookEdit")
|
||||
DEEP_DISALLOWED = (
|
||||
"AskUserQuestion",
|
||||
"ExitPlanMode",
|
||||
"EnterPlanMode",
|
||||
"NotebookEdit",
|
||||
"Task",
|
||||
)
|
||||
DISTILLER_DISALLOWED = ("AskUserQuestion", "Task", "WebSearch", "WebFetch")
|
||||
TRIAGE_DISALLOWED = DISTILLER_DISALLOWED
|
||||
|
||||
FILE_TOOLS = ("Write", "Edit", "MultiEdit", "NotebookEdit")
|
||||
MUTATING = frozenset(
|
||||
{
|
||||
"rm",
|
||||
"rmdir",
|
||||
"unlink",
|
||||
"mv",
|
||||
"cp",
|
||||
"tee",
|
||||
"truncate",
|
||||
"touch",
|
||||
"mkdir",
|
||||
"ln",
|
||||
"install",
|
||||
"rsync",
|
||||
"dd",
|
||||
"chmod",
|
||||
"chown",
|
||||
"shred",
|
||||
}
|
||||
)
|
||||
COPYING = frozenset({"cp", "install", "rsync"})
|
||||
DELETING = frozenset({"rm", "rmdir", "unlink", "shred", "dd", "truncate"})
|
||||
INPLACE = frozenset({"sed", "perl"})
|
||||
REDIRECTS = frozenset({">", ">>", ">|", "&>", "&>>", ">&"})
|
||||
SEPARATORS = frozenset({";", "&&", "||", "|", "&", "(", ")"})
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class Zones:
|
||||
"""Зоны vault.
|
||||
|
||||
``write`` - всё, включая удаление; ``create`` - только новые файлы;
|
||||
``edit`` - создавать, править, переносить можно, удалять - нет;
|
||||
``protected`` - не трогать. Приоритет: write > protected > create > edit;
|
||||
путь в vault вне всех зон - отказ.
|
||||
"""
|
||||
|
||||
vault: Path
|
||||
write: tuple[Path, ...]
|
||||
create: tuple[Path, ...] = ()
|
||||
edit: tuple[Path, ...] = ()
|
||||
protected: tuple[Path, ...] = ()
|
||||
|
||||
def verdict(
|
||||
self, path: Path, *, creating: bool, deleting: bool = False
|
||||
) -> Deny | None:
|
||||
if not _under(path, self.vault):
|
||||
return None
|
||||
if any(_under(path, zone) for zone in self.write):
|
||||
return None
|
||||
rel = path.relative_to(self.vault)
|
||||
for zone in self.protected:
|
||||
if _under(path, zone):
|
||||
return Deny(
|
||||
reason=f"{rel}: «{zone.relative_to(self.vault)}» не трогаем - "
|
||||
"это зона Бобра"
|
||||
)
|
||||
for zone in self.create:
|
||||
if _under(path, zone):
|
||||
if creating and not path.exists():
|
||||
return None
|
||||
return Deny(
|
||||
reason=f"{rel}: в «{zone.relative_to(self.vault)}» можно только "
|
||||
"создавать новые файлы, существующие не трогаем"
|
||||
)
|
||||
for zone in self.edit:
|
||||
if _under(path, zone):
|
||||
if deleting:
|
||||
zones = ", ".join(
|
||||
f"«{z.relative_to(self.vault)}»" for z in self.write
|
||||
)
|
||||
return Deny(
|
||||
reason=f"{rel}: удалять можно только в {zones}; чужие "
|
||||
"заметки не удаляем - скажи Бобру, он сам"
|
||||
)
|
||||
return None
|
||||
zones = ", ".join(f"«{z.relative_to(self.vault)}»" for z in self.write)
|
||||
return Deny(reason=f"{rel}: vault только на чтение; писать можно в {zones}")
|
||||
|
||||
|
||||
def _under(path: Path, root: Path) -> bool:
|
||||
return path == root or root in path.parents
|
||||
|
||||
|
||||
def vault_zones(zones: Zones) -> PolicyRule:
|
||||
"""Write/Edit/NotebookEdit только в зонах; Write в create-зону - новый файл."""
|
||||
|
||||
def rule(call: ToolCall) -> Deny | None:
|
||||
if call.tool not in FILE_TOOLS:
|
||||
return None
|
||||
path = call.path()
|
||||
if path is None:
|
||||
return None
|
||||
return zones.verdict(path, creating=call.tool == "Write")
|
||||
|
||||
return rule
|
||||
|
||||
|
||||
def bash_zones(zones: Zones) -> PolicyRule:
|
||||
"""`rm`/`mv`/`cp`/`tee`/`sed -i`/редирект с путём в vault вне зон - отказ."""
|
||||
|
||||
def rule(call: ToolCall) -> Deny | None:
|
||||
if call.tool != "Bash":
|
||||
return None
|
||||
command = call.input.get("command")
|
||||
if not isinstance(command, str):
|
||||
return None
|
||||
for target, creating, deleting in _bash_targets(command):
|
||||
deny = zones.verdict(
|
||||
call.resolve(target), creating=creating, deleting=deleting
|
||||
)
|
||||
if deny is not None:
|
||||
return Deny(reason=f"Bash: {deny.reason}")
|
||||
return None
|
||||
|
||||
return rule
|
||||
|
||||
|
||||
def _bash_targets(command: str) -> Iterator[tuple[str, bool, bool]]:
|
||||
"""``(путь, создаёт, удаляет)`` для каждого пути, который команда трогает."""
|
||||
for segment in _segments(command):
|
||||
plain: list[str] = []
|
||||
i = 0
|
||||
while i < len(segment):
|
||||
word = segment[i]
|
||||
if word in REDIRECTS:
|
||||
if i + 1 < len(segment) and _pathlike(segment[i + 1]):
|
||||
yield segment[i + 1], True, False
|
||||
i += 2
|
||||
continue
|
||||
plain.append(word)
|
||||
i += 1
|
||||
for j, word in enumerate(plain):
|
||||
rest = plain[j + 1 :]
|
||||
inplace = word in INPLACE and any(a.startswith("-i") for a in rest)
|
||||
if word not in MUTATING and not inplace:
|
||||
continue
|
||||
args = [a for a in rest if _pathlike(a)]
|
||||
if word in COPYING:
|
||||
args = args[-1:]
|
||||
for arg in args:
|
||||
yield arg, False, word in DELETING
|
||||
break
|
||||
|
||||
|
||||
def _segments(command: str) -> Iterator[list[str]]:
|
||||
lexer = shlex.shlex(command, posix=True, punctuation_chars=True)
|
||||
lexer.whitespace_split = True
|
||||
try:
|
||||
tokens = list(lexer)
|
||||
except ValueError:
|
||||
tokens = command.split()
|
||||
segment: list[str] = []
|
||||
for token in tokens:
|
||||
if token in SEPARATORS:
|
||||
if segment:
|
||||
yield segment
|
||||
segment = []
|
||||
else:
|
||||
segment.append(token)
|
||||
if segment:
|
||||
yield segment
|
||||
|
||||
|
||||
def _pathlike(word: str) -> bool:
|
||||
return bool(word) and not (
|
||||
word.startswith(("-", "&", "$", "/dev/"))
|
||||
or word.isdigit()
|
||||
or ("=" in word and "/" not in word.split("=", 1)[0])
|
||||
)
|
||||
|
||||
|
||||
def _skill_name(call: ToolCall) -> str:
|
||||
"""Имя скилла из `Skill({"skill": "vault:firefly", ...})`, без плагина."""
|
||||
name = str(call.input.get("skill") or call.input.get("name") or "")
|
||||
return name.rsplit(":", 1)[-1]
|
||||
|
||||
|
||||
def skill_tracker() -> PolicyRule:
|
||||
"""Запоминает открытые скиллы в состоянии сессии (для `requires_skill`)."""
|
||||
|
||||
def rule(call: ToolCall) -> None:
|
||||
if call.tool != "Skill":
|
||||
return
|
||||
opened: set[str] = call.state.setdefault("skills", set())
|
||||
opened.add(_skill_name(call))
|
||||
|
||||
return rule
|
||||
|
||||
|
||||
def forbid_skills(names: tuple[str, ...], kinds: tuple[str, ...]) -> PolicyRule:
|
||||
"""Скиллы из ``names`` (fnmatch, без учёта регистра) в ``kinds`` закрыты.
|
||||
|
||||
Мастер их не открывает - для этого есть ветка; правило отвечает так,
|
||||
чтобы модель сама её открыла.
|
||||
"""
|
||||
patterns = tuple(p.lower() for p in names)
|
||||
|
||||
def rule(call: ToolCall) -> Deny | None:
|
||||
if call.tool != "Skill" or call.kind not in kinds:
|
||||
return None
|
||||
name = _skill_name(call)
|
||||
if not any(fnmatch.fnmatchcase(name.lower(), p) for p in patterns):
|
||||
return None
|
||||
return Deny(reason=f"скилл {name} недоступен в {call.kind}: открой ветку")
|
||||
|
||||
return rule
|
||||
|
||||
|
||||
def requires_skill(skill: str, tools: tuple[str, ...]) -> PolicyRule:
|
||||
"""Тулзы из ``tools`` - только после `Skill(skill)` в той же сессии."""
|
||||
|
||||
def rule(call: ToolCall) -> Deny | None:
|
||||
if not any(fnmatch.fnmatchcase(call.tool, pattern) for pattern in tools):
|
||||
return None
|
||||
if skill in call.state.get("skills", ()):
|
||||
return None
|
||||
return Deny(
|
||||
reason=f"сначала открой скилл «{skill}» (тулза Skill), потом {call.tool}"
|
||||
)
|
||||
|
||||
return rule
|
||||
|
||||
|
||||
ZONES = Zones(
|
||||
vault=VAULT,
|
||||
write=(BEAVER,),
|
||||
create=(CHATS,),
|
||||
edit=(VAULT,),
|
||||
protected=(VAULT / ".obsidian", VAULT / "мета"),
|
||||
)
|
||||
"""Vault - дом диспетчера: создавать, править, переносить можно везде, кроме
|
||||
`.obsidian` и `мета` вне `бобер`; удалять - только своё и новые чаты."""
|
||||
|
||||
STRICT_ZONES = Zones(vault=VAULT, write=(BEAVER,), create=(CHATS,))
|
||||
"""Дистиллятор и куратор: писать только в своей зоне."""
|
||||
|
||||
FIREFLY_WRITES = ("mcp__firefly__store_*", "mcp__firefly__update_*")
|
||||
VAULT_POLICY = (
|
||||
skill_tracker(),
|
||||
vault_zones(ZONES),
|
||||
bash_zones(ZONES),
|
||||
requires_skill("firefly", FIREFLY_WRITES),
|
||||
)
|
||||
@@ -1,65 +0,0 @@
|
||||
"""Как собирается системный промпт каждой роли из гранул vault.
|
||||
|
||||
Гранула - чистый markdown; xml-тег, в который она заворачивается, задаётся
|
||||
здесь. Голос идёт первым и одинаков у всех, кто говорит с Бобром; окружение
|
||||
зависит от вида окна (мастер, ветка, глубокий, джоб); оверлей - от роли.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from beaver_gateway.agents.claude import Prompts
|
||||
from beaver_gateway.agents.prompts import assemble
|
||||
|
||||
from beaver_agent.vault import GRANULES, PROMPTS
|
||||
|
||||
VOICE = tuple(
|
||||
(tag, GRANULES / "голос" / f"{tag}.md")
|
||||
for tag in (
|
||||
"role",
|
||||
"philosophy",
|
||||
"user_profile",
|
||||
"operating_modes",
|
||||
"how_you_operate",
|
||||
"interaction_guidelines",
|
||||
)
|
||||
)
|
||||
PROFILE = ("profile", PROMPTS / "профиль.md")
|
||||
CORRECTIONS = ("corrections", PROMPTS / "поправки.md")
|
||||
VAULT_MAP = ("vault_map", GRANULES / "карта-vault.md")
|
||||
|
||||
|
||||
def environment(window: str) -> tuple[str, str]:
|
||||
return ("environment", str(GRANULES / "окружения" / f"{window}.md"))
|
||||
|
||||
|
||||
def overlay(tag: str, name: str) -> tuple[str, str]:
|
||||
return (tag, str(GRANULES / f"{name}.md"))
|
||||
|
||||
|
||||
BASE = (*VOICE, PROFILE, CORRECTIONS, VAULT_MAP)
|
||||
"""Голос, профиль Бобра, его поправки и карта vault - у всех, кто с ним говорит."""
|
||||
|
||||
DISTILL_AS_JOB = (*BASE, environment("джоб"), overlay("distiller", "дистиллятор"))
|
||||
"""Форк ветки пишет слив: тот же голос, окружение джоба, оверлей дистиллятора."""
|
||||
|
||||
DISPATCHER = Prompts(
|
||||
master=(*BASE, environment("мастер"), overlay("dispatcher", "диспетчер")),
|
||||
branch=(*BASE, environment("ветка"), overlay("branch", "ветка")),
|
||||
fork=DISTILL_AS_JOB,
|
||||
job=DISTILL_AS_JOB,
|
||||
)
|
||||
DEEP = Prompts(deep=(*BASE, environment("глубокий"), overlay("deep", "глубокий")))
|
||||
|
||||
DISTILLER_ONLY = (PROFILE, environment("джоб"), overlay("distiller", "дистиллятор"))
|
||||
"""Дистиллятор без голоса - иначе выжимки получаются с матом."""
|
||||
DISTILLER = Prompts(fork=DISTILLER_ONLY, job=DISTILLER_ONLY)
|
||||
TRIAGE = Prompts(job=(PROFILE, environment("джоб"), overlay("triage", "триаж")))
|
||||
CURATOR = Prompts(job=(*BASE, environment("джоб"), overlay("curator", "куратор")))
|
||||
|
||||
QUICK = assemble((*VOICE, PROFILE, overlay("quick", "быстрый")))
|
||||
"""Raycast-агенты: голос и профиль одной строкой, без vault."""
|
||||
|
||||
VOICE_AGENT = Prompts(
|
||||
branch=(*VOICE, environment("голосовой"), overlay("voice", "голосовой"))
|
||||
)
|
||||
"""Колонки: голос целиком, но без профиля, поправок и карты - vault ему не виден."""
|
||||
@@ -1,30 +0,0 @@
|
||||
"""Наборы скиллов по окнам: папка `мета/бобер/скиллы/<набор>` = плагин.
|
||||
|
||||
Мастер не получает `vault/` (firefly, Дерден): для этого есть ветка и
|
||||
глубокий чат. Форк и джоб диспетчера скиллов не грузят вовсе.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from beaver_gateway.agents.claude import SkillSets
|
||||
|
||||
from beaver_agent.vault import SKILLS
|
||||
|
||||
COMMON = SKILLS / "общие"
|
||||
DISPATCHER_ONLY = SKILLS / "диспетчер"
|
||||
VAULT_ONLY = SKILLS / "vault"
|
||||
|
||||
DISPATCHER = SkillSets(
|
||||
master=(COMMON, DISPATCHER_ONLY),
|
||||
branch=(COMMON, DISPATCHER_ONLY, VAULT_ONLY),
|
||||
fork=(),
|
||||
job=(),
|
||||
)
|
||||
DEEP = (COMMON, VAULT_ONLY)
|
||||
|
||||
MASTER_FORBIDDEN = (
|
||||
tuple(p.name for p in sorted(VAULT_ONLY.iterdir()) if p.is_dir())
|
||||
if VAULT_ONLY.exists()
|
||||
else ()
|
||||
)
|
||||
"""Без набора скилл и так не найдётся; правило нужно ради внятного отказа."""
|
||||
@@ -1,186 +0,0 @@
|
||||
"""Всё, что gateway говорит модели и Бобру, по-русски."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from beaver_gateway.conversations.texts import ConversationTexts, EnvelopeTexts
|
||||
from beaver_gateway.frontends.telegram import TelegramTexts
|
||||
|
||||
from beaver_agent.memory.handouts import (
|
||||
distill_prompt,
|
||||
handout_prompt,
|
||||
new_day,
|
||||
seed_body,
|
||||
)
|
||||
from beaver_agent.vault import GRANULES, read
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from beaver_gateway.conversations.injects import InjectContext
|
||||
|
||||
BEAVER_ORIGINS = frozenset({"panel", "api"})
|
||||
"""Панель и API - это сам Бобёр; крон, watch, komodo, ротация - нет."""
|
||||
|
||||
ORIGINS = {
|
||||
"merge": "слив",
|
||||
"digest": "выжимка",
|
||||
"rotation": "ротация",
|
||||
"cap": "потолок",
|
||||
"system": "система",
|
||||
"agent": "агент",
|
||||
}
|
||||
|
||||
INTERRUPTED_TURN = (
|
||||
"[этот инжект прервал предыдущий тёрн: «Request interrupted» выше - "
|
||||
"прерывание, не отказ от тулзы]"
|
||||
)
|
||||
|
||||
|
||||
def inject_header(ctx: InjectContext) -> str:
|
||||
if ctx.origin in BEAVER_ORIGINS:
|
||||
head = (
|
||||
"[инжект из панели: это Бобёр, ответ он видит в панели; "
|
||||
"в телегу - только через say]"
|
||||
)
|
||||
else:
|
||||
origin = ORIGINS.get(ctx.origin, ctx.origin)
|
||||
head = (
|
||||
f"[инжект: {origin} - это не Бобёр, отвечать не нужно, голос не обязателен]"
|
||||
)
|
||||
return f"{head}\n{INTERRUPTED_TURN}" if ctx.interrupted_turn else head
|
||||
|
||||
|
||||
ENVELOPE = EnvelopeTexts(
|
||||
header=(
|
||||
"[конверт - фоновый сигнал, не обращение; "
|
||||
"реагируй, только если относится к вопросу]"
|
||||
),
|
||||
time="время: {stamp} ({zone})",
|
||||
changed="vault, изменено {since}: {names}",
|
||||
since="с {time}",
|
||||
since_start="со старта",
|
||||
truncated="… (потолок конверта)",
|
||||
file_header="--- {path}, только добавленное ---",
|
||||
more_lines="+ … ещё {count}",
|
||||
)
|
||||
|
||||
MERGE_PROMPT = read(GRANULES / "слив.md") or (
|
||||
"Ветка закрывается. Напиши слив для мастера: что решили, что сделано, "
|
||||
"что не сделано и почему, открытые вопросы. Идентификаторы и ссылки - "
|
||||
"дословно. Коротко, прошедшее время."
|
||||
)
|
||||
|
||||
CONVERSATIONS = ConversationTexts(
|
||||
merge_prompt=MERGE_PROMPT,
|
||||
inject_header=inject_header,
|
||||
bundle_header="[инжекты, накопившиеся с {since}; это не Бобёр]",
|
||||
task_prompt="[субагент отчитался: {note}]",
|
||||
interrupted="прервано",
|
||||
answered="Пользователь ответил: {answer}",
|
||||
unanswered=(
|
||||
"Пользователь не ответил за {minutes} мин. Вопрос ему показан текстом; "
|
||||
"заверши тёрн сейчас, ответ придёт следующим сообщением."
|
||||
),
|
||||
seed=seed_body,
|
||||
seed_head="[сид: {seed}] {kind}{title}, {stamp}.",
|
||||
seed_copy="История родителя скопирована ({scope}); продолжай в ней.",
|
||||
seed_copy_window="последние {window} тёрнов",
|
||||
seed_copy_all="вся история",
|
||||
seed_morning_missing="Хендаут не приехал.",
|
||||
handout=handout_prompt,
|
||||
new_day=new_day,
|
||||
moved_injects=" Инжектов переехало из старого мастера: {moved}.",
|
||||
distill=distill_prompt,
|
||||
closed="Закрыт глубокий чат [[{chat}]]{digest}.\n{text}",
|
||||
closed_digest=", выжимка [[{digest}]]",
|
||||
digest_missing="файл выжимки не появился",
|
||||
too_long=(
|
||||
"`{name}`: {lines} строк при потолке {max_lines}. Запись отбита, файл "
|
||||
"возвращён к прежней версии. Сократи и перепиши."
|
||||
),
|
||||
cut_by_restart="тёрн {turn_id} оборван рестартом gateway",
|
||||
repaired_tools=(
|
||||
"; {fixed} незакрытых тул-коллов получили tool_result «{interrupted}»"
|
||||
),
|
||||
envelope=ENVELOPE,
|
||||
)
|
||||
|
||||
TELEGRAM = TelegramTexts(
|
||||
commands=(
|
||||
("merge", "слить ветку в мастер"),
|
||||
("new", "новая ветка: в General - новый топик, в топике - заново на нём"),
|
||||
("chat", "открыть глубокий чат в vault: /chat тема"),
|
||||
("status", "что с этим разговором"),
|
||||
("help", "команды"),
|
||||
),
|
||||
help_head="General - мастер, любой другой топик - ветка.",
|
||||
branch="ветка",
|
||||
waiting="⏳ думаю",
|
||||
thinking="🤔 думаю",
|
||||
writing="✍️ пишу",
|
||||
tool_labels={
|
||||
"Read": "читаю vault",
|
||||
"Glob": "ищу файлы",
|
||||
"Grep": "ищу в vault",
|
||||
"Edit": "правлю файл",
|
||||
"Write": "пишу файл",
|
||||
"MultiEdit": "правлю файлы",
|
||||
"Bash": "выполняю команду",
|
||||
"WebSearch": "ищу в сети",
|
||||
"WebFetch": "читаю страницу",
|
||||
"Task": "запустил сабагента",
|
||||
"Agent": "запустил сабагента",
|
||||
"AskUserQuestion": "спрашиваю",
|
||||
"TodoWrite": "планирую",
|
||||
"Skill": "открываю скилл",
|
||||
"mcp__gateway__spawn": "открываю разговор",
|
||||
"mcp__gateway__read_conversation": "читаю разговор",
|
||||
"mcp__gateway__say": "говорю",
|
||||
"mcp__gateway__schedule": "ставлю напоминание",
|
||||
"mcp__gateway__inject": "передаю в другой разговор",
|
||||
},
|
||||
attachment_sticker="[вложение: стикер - не поддерживается]",
|
||||
attachment_animation="[вложение: анимация - не поддерживается]",
|
||||
attachment_kinds={
|
||||
"photo": "фото",
|
||||
"document": "файл",
|
||||
"voice": "голосовое",
|
||||
"audio": "аудио",
|
||||
"video": "видео",
|
||||
"video_note": "кружок",
|
||||
},
|
||||
attachment_too_big=(
|
||||
"[вложение: {kind} {name}, {mb} МБ - больше 20 МБ, Telegram не отдаёт ботам]"
|
||||
),
|
||||
attachment_failed="[вложение: {kind} {name} - не скачалось: {error}]",
|
||||
attachment_size=", {kb} КБ",
|
||||
attachment="[вложение: {kind} {path}{size}]",
|
||||
attachment_kept=(
|
||||
"[вложение: {kind} {path}{size}; хранится {days} дн., "
|
||||
"перенеси в vault, если нужно]"
|
||||
),
|
||||
merge_nothing="сливать нечего: это не открытая ветка",
|
||||
merging="🔀 сливаю в мастер",
|
||||
merged="✅ слито в мастер",
|
||||
merge_failed="⚠️ слив не удался: {error}",
|
||||
new_branch_topic="🌿 ветка «{title}» - в новом топике",
|
||||
new_branch_here="🌿 новая ветка на этом топике",
|
||||
chat_usage="/chat <тема>",
|
||||
chat_failed="не вышло: {error}",
|
||||
chat_opened="💬 глубокий чат: {where}",
|
||||
status_unbound="этот топик ни к чему не привязан - напиши, и откроется ветка",
|
||||
status_line="сессия: {live} · тёрн: {turn} · в очереди: {queued}",
|
||||
status_live="живая",
|
||||
status_dead="нет",
|
||||
status_running="идёт",
|
||||
status_idle="нет",
|
||||
status_question="❓ ждёт ответа на вопрос",
|
||||
status_pool="пул: {sessions} сессий, rss {mb} МБ",
|
||||
status_outbox="outbox: {pending} в очереди",
|
||||
turn_failed="⚠️ тёрн упал, смотри логи gateway",
|
||||
background_failed="⚠️ фоновый тёрн ({origin}) упал, смотри логи gateway",
|
||||
question_closed="вопрос уже закрыт",
|
||||
question_timeout="⌛ время вышло - ответь текстом",
|
||||
done_button="✅ готово",
|
||||
mirrored="📝 из панели:\n{text}",
|
||||
)
|
||||
@@ -1,57 +0,0 @@
|
||||
"""Где что лежит в vault и в какой зоне живёт агент."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from zoneinfo import ZoneInfo
|
||||
|
||||
TZ = "Europe/Warsaw"
|
||||
ZONE = ZoneInfo(TZ)
|
||||
LAUNCH = datetime(2026, 8, 28, tzinfo=ZONE)
|
||||
"""Ночное закрытие трогает только чаты с активностью после запуска системы."""
|
||||
|
||||
VAULT = Path(os.environ.get("BEAVER_VAULT", "/vault"))
|
||||
"""`/vault` в контейнере; `BEAVER_VAULT` - чтобы собрать конфиг на маке."""
|
||||
CHATS = VAULT / "💬 чаты"
|
||||
DIARY = VAULT / "📅 дни"
|
||||
PEOPLE = VAULT / "👤 люди"
|
||||
BOARDS = VAULT / "📆 доски"
|
||||
THOUGHTS = VAULT / "🧠 мысли"
|
||||
|
||||
BEAVER = VAULT / "мета" / "бобер"
|
||||
"""Дом агента: всё, что он ведёт сам, лежит здесь."""
|
||||
PROMPTS = BEAVER / "промпты"
|
||||
GRANULES = PROMPTS / "гранулы"
|
||||
SKILLS = BEAVER / "скиллы"
|
||||
DAYS = BEAVER / "дни"
|
||||
DIGESTS = BEAVER / "выжимки"
|
||||
INDEX = BEAVER / "индекс.md"
|
||||
NOTES = BEAVER / "наблюдения"
|
||||
PORTRAIT = NOTES / "Бобёр - наблюдения.md"
|
||||
REPLIES = BEAVER / "реплики"
|
||||
CURATOR_JOURNAL = BEAVER / "куратор.md"
|
||||
"""Первая строка - время прошлого прогона; сами записи лежат в `CURATOR_RUNS`."""
|
||||
CURATOR_RUNS = BEAVER / "куратор"
|
||||
OWN_DIARY = BEAVER / "дневник"
|
||||
"""Его собственный дневник, файл на день: то, что он думает, без логов."""
|
||||
JOURNAL = BEAVER / "журнал"
|
||||
"""Рабочий журнал, файл на день: следы тиков, логи, разбор промахов."""
|
||||
LEISURE = BEAVER / "досуг.md"
|
||||
"""Раскладка суток по тикам досуга: пишет её модель, механизм только читает."""
|
||||
STATE_DIR = Path(os.environ.get("BEAVER_STATE_DIR", BEAVER / ".состояние"))
|
||||
"""Машинное состояние джобов (не для чтения моделью): лежит в доме агента, а не
|
||||
в корне vault - структуру верхних папок ведёт владелец. Точка в начале: такой
|
||||
каталог Obsidian не показывает, а watcher смотрит только `.md`. Создаётся сам."""
|
||||
STATE = BEAVER / "состояние.md"
|
||||
STATE_MAX_LINES = 60
|
||||
ATTACHMENTS = BEAVER / "вложения"
|
||||
|
||||
|
||||
def today() -> str:
|
||||
return datetime.now(ZONE).date().isoformat()
|
||||
|
||||
|
||||
def read(path: Path) -> str | None:
|
||||
return path.read_text(encoding="utf-8").strip() if path.exists() else None
|
||||
@@ -1,16 +0,0 @@
|
||||
"""Голосовые точки по квартире: своя ветка, свой дешёвый агент, свои ключи."""
|
||||
|
||||
from beaver_agent.voice.frontend import VoiceFrontend
|
||||
from beaver_agent.voice.texts import KEY, TITLE
|
||||
from beaver_agent.voice.thread import AGENT, FRONTEND, current, open_thread, rotate
|
||||
|
||||
__all__ = [
|
||||
"AGENT",
|
||||
"FRONTEND",
|
||||
"KEY",
|
||||
"TITLE",
|
||||
"VoiceFrontend",
|
||||
"current",
|
||||
"open_thread",
|
||||
"rotate",
|
||||
]
|
||||
@@ -1,266 +0,0 @@
|
||||
"""Окно голосовых точек: ESP32 шлёт json на /voice, отвечает дешёвый агент."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import asyncio
|
||||
import json
|
||||
import logging
|
||||
from typing import TYPE_CHECKING, Any
|
||||
from uuid import uuid4
|
||||
|
||||
from beaver_gateway.agents.claude import ClaudeAgent
|
||||
from beaver_gateway.conversations.turns import content_of
|
||||
from beaver_gateway.frontends.accumulate import StreamAccumulator
|
||||
from beaver_gateway.frontends.base import Frontend
|
||||
from beaver_gateway.frontends.bearer import require_token
|
||||
from beaver_gateway.frontends.sse import (
|
||||
KEEPALIVE,
|
||||
SSE_HEADERS,
|
||||
events_with_heartbeat,
|
||||
sse_pack,
|
||||
)
|
||||
from beaver_gateway.security import audit
|
||||
from fastapi import FastAPI, HTTPException, Request, status
|
||||
from fastapi.responses import JSONResponse, StreamingResponse
|
||||
|
||||
from beaver_agent.voice import texts
|
||||
from beaver_agent.voice.thread import FRONTEND, current, open_thread
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from collections.abc import AsyncIterator, Mapping
|
||||
|
||||
from beaver_gateway.frontends.base import GatewayRuntime
|
||||
from beaver_gateway.storage.models import Conversation
|
||||
|
||||
_log = logging.getLogger("beaver_agent.voice")
|
||||
|
||||
FIELDS = ("room", "device", "content")
|
||||
|
||||
|
||||
class VoiceFrontend(Frontend):
|
||||
"""Одна ветка на всю квартиру, свой агент, свои ключи.
|
||||
|
||||
Тёрн идёт мимо очереди, а значит и мимо конверта: справка по vault в
|
||||
этот разговор не попадает даже случайно. В телеграм-ветку вопрос
|
||||
кладётся отдельной репликой, ответ пишется черновиком, как обычно.
|
||||
|
||||
Отвечает SSE по умолчанию - колонке важно начать говорить раньше;
|
||||
`"stream": false` в теле переключает на один JSON.
|
||||
"""
|
||||
|
||||
name = FRONTEND
|
||||
kinds = ("branch",)
|
||||
path = "/voice"
|
||||
scope = "voice"
|
||||
|
||||
def __init__(self, *, agent: str, timeout: float = 90.0) -> None:
|
||||
self.agent = agent
|
||||
self.timeout = timeout
|
||||
"""Сколько ждать ответа; дальше 504, а тёрн договаривает в телеграм."""
|
||||
self._runtime: GatewayRuntime | None = None
|
||||
self._app: FastAPI | None = None
|
||||
self._lock = asyncio.Lock()
|
||||
self._late: set[asyncio.Task[Any]] = set()
|
||||
|
||||
def configure(self, runtime: GatewayRuntime) -> None:
|
||||
if runtime.conversations is None or runtime.bus is None:
|
||||
msg = "VoiceFrontend: нужны runtime.conversations и runtime.bus"
|
||||
raise RuntimeError(msg)
|
||||
agent = runtime.agents.get(self.agent)
|
||||
if not isinstance(agent, ClaudeAgent) or not agent.serves("branch"):
|
||||
msg = f"VoiceFrontend: агент {self.agent!r} не обслуживает ветки"
|
||||
raise RuntimeError(msg)
|
||||
self._runtime = runtime
|
||||
self._app = self._build_app(runtime)
|
||||
|
||||
def app(self) -> FastAPI | None:
|
||||
return self._app
|
||||
|
||||
def _build_app(self, runtime: GatewayRuntime) -> FastAPI:
|
||||
app = FastAPI(title="beaver-agent / голосовой")
|
||||
|
||||
@app.get("/healthz")
|
||||
async def healthz() -> dict[str, str]:
|
||||
return {"status": "ok", "frontend": self.name}
|
||||
|
||||
@app.post("/")
|
||||
async def ask(request: Request) -> Any:
|
||||
token = await require_token(request, runtime, scope=self.scope)
|
||||
body = await _body(request)
|
||||
room, device, content = (_field(body, name) for name in FIELDS)
|
||||
conv = await self.thread()
|
||||
await audit.log(
|
||||
runtime,
|
||||
actor=f"token:{token}",
|
||||
kind="voice_ask",
|
||||
agent_name=conv.agent_name,
|
||||
conversation=conv.external_id,
|
||||
room=room,
|
||||
device=device,
|
||||
request_id=body.get("request_id"),
|
||||
)
|
||||
_log.info("голос: %s/%s -> %s", room, device, conv.external_id)
|
||||
await runtime.conversations.say(
|
||||
conv, texts.ASKED.format(room=room, device=device, text=content)
|
||||
)
|
||||
prompt = await self._prompt(
|
||||
conv, texts.HEARD.format(room=room, device=device, text=content)
|
||||
)
|
||||
if _flag(body, "stream", default=True):
|
||||
return StreamingResponse(
|
||||
self._sse(conv, prompt, body),
|
||||
media_type="text/event-stream",
|
||||
headers=SSE_HEADERS,
|
||||
)
|
||||
return JSONResponse(await self._answer(conv, prompt, body))
|
||||
|
||||
@app.exception_handler(HTTPException)
|
||||
async def http_error(_request: Request, exc: HTTPException) -> JSONResponse:
|
||||
return JSONResponse(
|
||||
status_code=exc.status_code,
|
||||
content={"error": exc.detail},
|
||||
headers=exc.headers,
|
||||
)
|
||||
|
||||
return app
|
||||
|
||||
async def thread(self) -> Conversation:
|
||||
conversations = self.runtime.conversations
|
||||
async with self._lock:
|
||||
conv = await current(conversations)
|
||||
if conv is not None:
|
||||
return conv
|
||||
return await open_thread(conversations, agent=self.agent)
|
||||
|
||||
@property
|
||||
def runtime(self) -> GatewayRuntime:
|
||||
if self._runtime is None:
|
||||
msg = "VoiceFrontend: configure() не вызывали"
|
||||
raise RuntimeError(msg)
|
||||
return self._runtime
|
||||
|
||||
async def _prompt(self, conv: Conversation, text: str) -> str:
|
||||
seed = await self.runtime.conversations.pending_seed(conv)
|
||||
return f"{seed}\n\n{text}" if seed else text
|
||||
|
||||
async def _answer(
|
||||
self, conv: Conversation, prompt: str, body: Mapping[str, Any]
|
||||
) -> dict[str, Any]:
|
||||
turn_id = _turn_id()
|
||||
task = asyncio.create_task(self._run(conv, prompt, turn_id))
|
||||
self._late.add(task)
|
||||
task.add_done_callback(self._late.discard)
|
||||
done, _ = await asyncio.wait({task}, timeout=self.timeout)
|
||||
if not done:
|
||||
_log.warning("голос: %s не уложился в %.0f c", turn_id, self.timeout)
|
||||
raise HTTPException(
|
||||
status.HTTP_504_GATEWAY_TIMEOUT, "агент не успел; ответ уйдёт в ветку"
|
||||
)
|
||||
return _body_out(body, reply=task.result(), conv=conv)
|
||||
|
||||
async def _run(self, conv: Conversation, prompt: str, turn_id: str) -> str:
|
||||
reply, _capture = await self.runtime.conversations.run_text_turn(
|
||||
conv, prompt, origin="user", turn_id=turn_id
|
||||
)
|
||||
self._published(conv, reply=reply, turn_id=turn_id)
|
||||
return reply
|
||||
|
||||
async def _sse(
|
||||
self, conv: Conversation, prompt: str, body: Mapping[str, Any]
|
||||
) -> AsyncIterator[bytes]:
|
||||
turn_id = _turn_id()
|
||||
acc = StreamAccumulator()
|
||||
model = self.runtime.agents[conv.agent_name].model
|
||||
try:
|
||||
events = self.runtime.conversations.turn(
|
||||
conv,
|
||||
messages=[{"role": "user", "content": content_of(prompt, None)}],
|
||||
origin="user",
|
||||
turn_id=turn_id,
|
||||
)
|
||||
async for event in events_with_heartbeat(events):
|
||||
if event is None:
|
||||
yield KEEPALIVE
|
||||
continue
|
||||
acc.feed(event)
|
||||
chunk = _text_delta(event)
|
||||
if chunk:
|
||||
yield sse_pack("delta", {"text": chunk})
|
||||
except Exception as exc: # noqa: BLE001
|
||||
_log.exception("голос: тёрн %s упал", turn_id)
|
||||
yield sse_pack("error", {"error": str(exc)})
|
||||
return
|
||||
reply = _text_of(acc.finalize(model=model))
|
||||
self._published(conv, reply=reply, turn_id=turn_id)
|
||||
yield sse_pack("done", _body_out(body, reply=reply, conv=conv))
|
||||
|
||||
def _published(self, conv: Conversation, *, reply: str, turn_id: str) -> None:
|
||||
self.runtime.bus.publish(
|
||||
"reply",
|
||||
conversation_id=conv.external_id,
|
||||
turn_id=turn_id,
|
||||
source=self.name,
|
||||
text=reply,
|
||||
)
|
||||
|
||||
|
||||
async def _body(request: Request) -> Mapping[str, Any]:
|
||||
try:
|
||||
data = await request.json()
|
||||
except json.JSONDecodeError as exc:
|
||||
raise HTTPException(status.HTTP_400_BAD_REQUEST, f"кривой json: {exc}") from exc
|
||||
if not isinstance(data, dict):
|
||||
raise HTTPException(status.HTTP_400_BAD_REQUEST, "тело должно быть объектом")
|
||||
return data
|
||||
|
||||
|
||||
def _flag(body: Mapping[str, Any], name: str, *, default: bool) -> bool:
|
||||
"""Флаг из тела; строку разбираем словом, иначе `"false"` включит стрим."""
|
||||
value = body.get(name)
|
||||
if value is None:
|
||||
return default
|
||||
if isinstance(value, str):
|
||||
return value.strip().lower() in ("1", "true", "yes", "on")
|
||||
return bool(value)
|
||||
|
||||
|
||||
def _field(body: Mapping[str, Any], name: str) -> str:
|
||||
value = body.get(name)
|
||||
if not isinstance(value, str) or not value.strip():
|
||||
raise HTTPException(
|
||||
status.HTTP_400_BAD_REQUEST, f"нужно непустое строковое поле {name!r}"
|
||||
)
|
||||
return value.strip()
|
||||
|
||||
|
||||
def _body_out(
|
||||
body: Mapping[str, Any], *, reply: str, conv: Conversation
|
||||
) -> dict[str, Any]:
|
||||
return {
|
||||
"request_id": body.get("request_id"),
|
||||
"room": body.get("room"),
|
||||
"device": body.get("device"),
|
||||
"reply": reply,
|
||||
"conversation": conv.external_id,
|
||||
}
|
||||
|
||||
|
||||
def _turn_id() -> str:
|
||||
return f"turn_{uuid4().hex[:12]}"
|
||||
|
||||
|
||||
def _text_delta(event: Any) -> str:
|
||||
if getattr(event, "type", "") != "content_block_delta":
|
||||
return ""
|
||||
delta = getattr(event, "delta", None)
|
||||
if getattr(delta, "type", "") != "text_delta":
|
||||
return ""
|
||||
return getattr(delta, "text", "")
|
||||
|
||||
|
||||
def _text_of(message: Any) -> str:
|
||||
return "\n\n".join(
|
||||
getattr(b, "text", "")
|
||||
for b in message.content
|
||||
if getattr(b, "type", "") == "text"
|
||||
).strip()
|
||||
@@ -1,17 +0,0 @@
|
||||
"""Что видно в телеграм-ветке голосовых точек; промпт - гранулы vault."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
TITLE = "🎤 Голосовой"
|
||||
"""Имя ветки; телеграм заводит топик под этим именем."""
|
||||
|
||||
KEY = "квартира"
|
||||
"""Ключ единственного треда: одна ветка на всю квартиру."""
|
||||
|
||||
ASKED = "🎤 {room} · {device}\n{text}"
|
||||
"""Вопрос, как он показывается в телеграм-ветке."""
|
||||
|
||||
HEARD = "[{room} · {device}] {text}"
|
||||
"""Вопрос, как его видит модель."""
|
||||
|
||||
ROTATED = "🎤 Новый день - ветка начата заново, прошлого разговора агент не помнит."
|
||||
@@ -1,62 +0,0 @@
|
||||
"""Единственная ветка голосовых точек: как её открыть и как сменить за ночь."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import logging
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from beaver_agent.voice.texts import KEY, ROTATED, TITLE
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from beaver_gateway.conversations.service import Conversations
|
||||
from beaver_gateway.storage.models import Conversation
|
||||
|
||||
AGENT = "beaver-voice"
|
||||
"""Кто сидит в голосовой ветке; ему не видно ни справки, ни vault."""
|
||||
|
||||
FRONTEND = "voice"
|
||||
TELEGRAM = "telegram"
|
||||
|
||||
_log = logging.getLogger("beaver_agent.voice")
|
||||
|
||||
|
||||
async def current(conversations: Conversations) -> Conversation | None:
|
||||
conv = await conversations.find_bound(frontend=FRONTEND, external_id=KEY)
|
||||
return conv if conv is not None and conv.status == "open" else None
|
||||
|
||||
|
||||
async def open_thread(
|
||||
conversations: Conversations, *, agent: str, window: str | None = None
|
||||
) -> Conversation:
|
||||
"""Завести ветку; без ``window`` окно ей открывает телеграм - новым топиком."""
|
||||
conv = await conversations.spawn(
|
||||
kind="branch",
|
||||
agent=agent,
|
||||
title=TITLE,
|
||||
origin=FRONTEND,
|
||||
binding=(TELEGRAM, window) if window else None,
|
||||
)
|
||||
await conversations.bind(conv, frontend=FRONTEND, external_id=KEY)
|
||||
_log.info("голосовая ветка %s (%s)", conv.external_id, agent)
|
||||
return conv
|
||||
|
||||
|
||||
async def window_of(conversations: Conversations, conv: Conversation) -> str | None:
|
||||
for binding in await conversations.bindings(conv):
|
||||
if binding.frontend == TELEGRAM and binding.visible:
|
||||
return binding.external_id
|
||||
return None
|
||||
|
||||
|
||||
async def rotate(conversations: Conversations) -> Conversation | None:
|
||||
"""Ночью - новая ветка в том же топике; молчавшую за сутки не трогаем."""
|
||||
old = await current(conversations)
|
||||
if old is None or old.last_user_activity_at is None:
|
||||
return None
|
||||
new = await open_thread(
|
||||
conversations, agent=old.agent_name, window=await window_of(conversations, old)
|
||||
)
|
||||
await conversations.close(old)
|
||||
await conversations.say(new, ROTATED)
|
||||
_log.info("голосовая ветка: %s -> %s", old.external_id, new.external_id)
|
||||
return new
|
||||
@@ -1,5 +1 @@
|
||||
BEAVER_DOMAIN=beaver.localhost
|
||||
# куда ходить за gateway; из контейнера caddy хост - host.docker.internal
|
||||
BEAVER_UPSTREAM=host.docker.internal:62990
|
||||
# только с acme_dns в Caddyfile
|
||||
CLOUDFLARE_API_TOKEN=
|
||||
+29
-13
@@ -1,24 +1,40 @@
|
||||
# Скелет для одиночного сервера: глобальный блок и import роутов проекта.
|
||||
# Роуты - в site.caddy, домен и апстрим - в .env.
|
||||
{
|
||||
admin off
|
||||
# Локально - самоподписанные сертификаты. На сервере с Cloudflare
|
||||
# закомментировать local_certs, раскомментировать acme_dns.
|
||||
local_certs
|
||||
# acme_dns cloudflare {env.CLOUDFLARE_API_TOKEN}
|
||||
|
||||
log {
|
||||
format console
|
||||
}
|
||||
|
||||
# servers {
|
||||
# trusted_proxies cloudflare
|
||||
# client_ip_headers Cf-Connecting-Ip
|
||||
# }
|
||||
servers {
|
||||
trusted_proxies cloudflare
|
||||
client_ip_headers Cf-Connecting-Ip
|
||||
}
|
||||
}
|
||||
|
||||
(compress) {
|
||||
encode zstd gzip
|
||||
}
|
||||
<DOMAIN> {
|
||||
redir /anthropic /anthropic/ 308
|
||||
redir /mcp /mcp/ 308
|
||||
redir /admin /admin/ 308
|
||||
redir /md /md/ 308
|
||||
|
||||
import /etc/caddy/projects.d/*/site.caddy
|
||||
handle_path /anthropic/* {
|
||||
reverse_proxy host.docker.internal:62990
|
||||
}
|
||||
handle_path /mcp/* {
|
||||
reverse_proxy host.docker.internal:62991
|
||||
}
|
||||
handle_path /admin/* {
|
||||
reverse_proxy host.docker.internal:62992
|
||||
}
|
||||
handle_path /md/* {
|
||||
reverse_proxy host.docker.internal:62993
|
||||
}
|
||||
# API разговоров + SSE для панели плагина: handle, не handle_path -
|
||||
# приложение само живёт под /api/…
|
||||
handle /api/* {
|
||||
reverse_proxy host.docker.internal:62994 {
|
||||
flush_interval -1
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -9,9 +9,7 @@ services:
|
||||
extra_hosts:
|
||||
- "host.docker.internal:host-gateway"
|
||||
volumes:
|
||||
- ./Caddyfile:/etc/caddy/Caddyfile:ro
|
||||
# каталог, не файл: git меняет inode, одиночный bind-mount залипает
|
||||
- ./:/etc/caddy/projects.d/beaver-agent:ro
|
||||
- ./Caddyfile:/etc/caddy/Caddyfile
|
||||
- caddy_data:/data
|
||||
env_file:
|
||||
- .env
|
||||
|
||||
@@ -1,11 +0,0 @@
|
||||
# Роуты beaver. Один апстрим, префиксы не срезаются: gateway сам живёт под
|
||||
# /anthropic, /mcp, /md, /api, /admin, /voice, а / ведёт в админку.
|
||||
# Домен и апстрим - из env сервера (domains.env / .env), tls - забота
|
||||
# серверного Caddyfile.
|
||||
{$BEAVER_DOMAIN} {
|
||||
import compress
|
||||
reverse_proxy {$BEAVER_UPSTREAM:localhost:62990} {
|
||||
# SSE и стримы ответов - без буферизации
|
||||
flush_interval -1
|
||||
}
|
||||
}
|
||||
@@ -1,47 +1,264 @@
|
||||
"""Сборка gateway для Бобра. Что где: пакет `beaver_agent/`.
|
||||
|
||||
- vault.py - пути и зона агента; prompts.py - как из гранул собирается промпт роли;
|
||||
- skills.py - наборы скиллов по окнам; policy.py - что можно трогать в vault;
|
||||
- hands/ - MCP-руки и кому какая выдана; agents.py - роли и их экземпляры;
|
||||
- frontends.py - окна; voice/ - голосовые точки по квартире и их ветка;
|
||||
- texts.py - всё, что gateway говорит, по-русски;
|
||||
- memory/ - справка, реплики, хендауты, вотчер, куратор; jobs/ - кроны и вебхуки.
|
||||
"""
|
||||
|
||||
import os
|
||||
from datetime import date, timedelta
|
||||
from pathlib import Path
|
||||
|
||||
from beaver_gateway.config import Gateway
|
||||
from beaver_gateway.conversations.distill import Distiller
|
||||
from beaver_gateway.conversations.rotation import RotationPolicy
|
||||
from beaver_gateway.jobs.scheduler import Budget
|
||||
from beaver_gateway.agents.base import BaseAgent, ExposedMcp
|
||||
from beaver_gateway.agents.claude import ClaudeAgent, ClaudeOptions, Prompts
|
||||
from beaver_gateway.agents.raycast import RaycastAgent, RemoteTool, UserPreferences
|
||||
from beaver_gateway.core.conversations import ConversationTexts, SeedContext
|
||||
from beaver_gateway.core.prompt import assemble
|
||||
from beaver_gateway.core.registry import Gateway
|
||||
from beaver_gateway.core.turn_record import slugify
|
||||
from beaver_gateway.frontends.admin import AdminFrontend
|
||||
from beaver_gateway.frontends.anthropic import AnthropicMessagesFrontend
|
||||
from beaver_gateway.frontends.api import ApiFrontend
|
||||
from beaver_gateway.frontends.base import Frontend
|
||||
from beaver_gateway.frontends.markdown import MarkdownFrontend
|
||||
from beaver_gateway.frontends.mcp_server import McpServerFrontend
|
||||
from beaver_gateway.mcp.types import HttpMcp, McpServer, McpServerT
|
||||
|
||||
from beaver_agent import texts
|
||||
from beaver_agent.agents import agents
|
||||
from beaver_agent.frontends import frontends
|
||||
from beaver_agent.hands import mcps
|
||||
from beaver_agent.jobs import jobs
|
||||
from beaver_agent.memory.watch import recall, replies, watch
|
||||
from beaver_agent.vault import DIGESTS, INDEX, TZ
|
||||
VAULT = Path("/vault")
|
||||
CHATS_DIR = VAULT / "💬 чаты"
|
||||
BEAVER = VAULT / "мета" / "бобер"
|
||||
PROMPTS = BEAVER / "промпты"
|
||||
GRANULES = PROMPTS / "гранулы"
|
||||
SKILLS = BEAVER / "скиллы"
|
||||
|
||||
gateway = Gateway(
|
||||
agents=agents,
|
||||
mcps=mcps,
|
||||
frontends=frontends,
|
||||
texts=texts.CONVERSATIONS,
|
||||
jobs=jobs,
|
||||
rotation=RotationPolicy(tz=TZ, max_context_tokens=500_000),
|
||||
watch=watch,
|
||||
recall=recall.block,
|
||||
user_sink=replies.write,
|
||||
budget=Budget(threshold=0.7),
|
||||
distiller=Distiller(
|
||||
agent="beaver-distiller",
|
||||
dir=DIGESTS,
|
||||
index=INDEX,
|
||||
type="выжимка",
|
||||
index_header="# индекс\n\nстрока на выжимку: чат → его выжимка.\n",
|
||||
),
|
||||
tz=TZ,
|
||||
port=62990,
|
||||
public_url=os.environ.get("PUBLIC_BASE_URL", "").rstrip("/") or None,
|
||||
# Гранулы - чистый markdown; xml-теги, в которые они заворачиваются,
|
||||
# живут здесь. Голос - папка, файл на тег, в этом порядке.
|
||||
VOICE = tuple(
|
||||
(tag, GRANULES / "голос" / f"{tag}.md")
|
||||
for tag in (
|
||||
"role",
|
||||
"philosophy",
|
||||
"user_profile",
|
||||
"operating_modes",
|
||||
"how_you_operate",
|
||||
"interaction_guidelines",
|
||||
)
|
||||
)
|
||||
PROFILE = ("profile", PROMPTS / "профиль.md")
|
||||
CORRECTIONS = ("corrections", PROMPTS / "поправки.md")
|
||||
VAULT_MAP = ("vault_map", GRANULES / "карта-vault.md")
|
||||
|
||||
|
||||
def environment(kind: str) -> tuple[str, Path]:
|
||||
return ("environment", GRANULES / "окружения" / f"{kind}.md")
|
||||
|
||||
|
||||
def overlay(tag: str, name: str) -> tuple[str, Path]:
|
||||
return (tag, GRANULES / f"{name}.md")
|
||||
|
||||
|
||||
# §4.2: сборки промптов. Окружение kind'а - константная гранула, экземплярное
|
||||
# (файл, топик) едет первым сообщением. Какие kind агент обслуживает, следует
|
||||
# из того, какие промпты у него заданы (§3.12).
|
||||
_BASE = (*VOICE, PROFILE, CORRECTIONS, VAULT_MAP)
|
||||
_DISTILL = (*_BASE, environment("джоб"), overlay("distiller", "дистиллятор"))
|
||||
|
||||
DEEP_PROMPTS = Prompts(
|
||||
deep=(*_BASE, environment("глубокий"), overlay("deep", "глубокий"))
|
||||
)
|
||||
# Диспетчер: тот же голос, окружение по kind, оверлей по роли.
|
||||
# Форк ветки (слив) думает как дистиллятор в окружении джоба.
|
||||
DISPATCHER_PROMPTS = Prompts(
|
||||
master=(*_BASE, environment("мастер"), overlay("dispatcher", "диспетчер")),
|
||||
branch=(*_BASE, environment("ветка"), overlay("branch", "ветка")),
|
||||
fork=_DISTILL,
|
||||
job=_DISTILL,
|
||||
)
|
||||
QUICK_PROMPT = assemble((*VOICE, PROFILE, overlay("quick", "быстрый")))
|
||||
|
||||
# §4.3: наборы скиллов = папки = плагины. Глубокие грузят общие + vault.
|
||||
DEEP_SKILLS = (SKILLS / "общие", SKILLS / "vault")
|
||||
DISPATCHER_SKILLS = (SKILLS / "общие", SKILLS / "диспетчер", SKILLS / "vault")
|
||||
|
||||
|
||||
def chat_path(title: str, agent: str, vault: Path) -> Path: # noqa: ARG001
|
||||
"""Новый файл чата в `💬 чаты/`: помесячная папка, дата и тема."""
|
||||
today = date.today()
|
||||
return (
|
||||
vault / f"{today:%Y-%m}" / f"{today:%Y-%m-%d} - {slugify(title, maxlen=60)}.md"
|
||||
)
|
||||
|
||||
|
||||
def _calendar_mcps() -> list[HttpMcp]:
|
||||
raw = os.environ.get("CALENDAR_MCPS", "").strip()
|
||||
servers: list[HttpMcp] = []
|
||||
for raw_entry in raw.split(","):
|
||||
entry = raw_entry.strip()
|
||||
if not entry:
|
||||
continue
|
||||
name, sep, url = entry.partition("=")
|
||||
if not sep or not url.strip():
|
||||
msg = f"CALENDAR_MCPS entry must be `name=url`, got: {entry!r}"
|
||||
raise ValueError(msg)
|
||||
servers.append(McpServer.http(name=f"calendar-{name.strip()}", url=url.strip()))
|
||||
return servers
|
||||
|
||||
|
||||
calendar_mcps = _calendar_mcps()
|
||||
calendar_exposed = tuple(ExposedMcp(name=m.name) for m in calendar_mcps)
|
||||
|
||||
# Секреты MCP - только через env подпроцесса (mcp stdio даёт ему белый список
|
||||
# + это), никогда argv: процесс модели видит `ps` всего контейнера.
|
||||
mcps: list[McpServerT] = [
|
||||
McpServer.stdio(
|
||||
name="obsidian-fs",
|
||||
command=["bunx", "-y", "@modelcontextprotocol/server-filesystem", "/vault"],
|
||||
lenient=True,
|
||||
),
|
||||
McpServer.stdio(
|
||||
name="firefly",
|
||||
command=["bunx", "-y", "@firefly-iii-mcp/local", "--preset", "default"],
|
||||
env={
|
||||
"FIREFLY_III_PAT": os.environ["FIREFLY_PAT"],
|
||||
"FIREFLY_III_BASE_URL": os.environ["FIREFLY_BASE_URL"],
|
||||
},
|
||||
lenient=True,
|
||||
),
|
||||
McpServer.http(name="telegram", url=os.environ["BEAVERGRAM_MCP"]),
|
||||
*calendar_mcps,
|
||||
]
|
||||
|
||||
# Руки глубокого (§4.4): firefly без delete_*, obsidian-fs не даётся - свои
|
||||
# файловые тулзы есть, vault смонтирован в /vault.
|
||||
CLAUDE_MCPS = (
|
||||
ExposedMcp(name="firefly", deny=("delete_*",)),
|
||||
ExposedMcp(name="telegram"),
|
||||
*calendar_exposed,
|
||||
)
|
||||
|
||||
|
||||
UserPrefsRu = lambda: UserPreferences( # noqa: E731
|
||||
locale="ru-RU", timezone="Europe/Warsaw", current_date=date.today().isoformat()
|
||||
)
|
||||
|
||||
|
||||
def dispatcher(name: str, model: str, effort: str | None = None) -> ClaudeAgent:
|
||||
return ClaudeAgent(
|
||||
name=name,
|
||||
model=model,
|
||||
cwd=VAULT,
|
||||
prompts=DISPATCHER_PROMPTS,
|
||||
skill_sets=DISPATCHER_SKILLS,
|
||||
gateway_tools=("read_conversation", "spawn", "say", "schedule"),
|
||||
options=ClaudeOptions(
|
||||
effort=effort,
|
||||
# §3.7: у диспетчера AskUserQuestion остаётся, планов и ноутбуков нет.
|
||||
disallowed_tools=("ExitPlanMode", "EnterPlanMode", "NotebookEdit"),
|
||||
),
|
||||
expose_mcps=CLAUDE_MCPS,
|
||||
)
|
||||
|
||||
|
||||
def deep(name: str, model: str, effort: str | None = None) -> ClaudeAgent:
|
||||
return ClaudeAgent(
|
||||
name=name,
|
||||
model=model,
|
||||
cwd=VAULT,
|
||||
prompts=DEEP_PROMPTS,
|
||||
skill_sets=DEEP_SKILLS,
|
||||
options=ClaudeOptions(
|
||||
effort=effort,
|
||||
# §3.7: у глубоких вопросы текстом, планов и сабагентов нет.
|
||||
disallowed_tools=(
|
||||
"AskUserQuestion",
|
||||
"ExitPlanMode",
|
||||
"EnterPlanMode",
|
||||
"NotebookEdit",
|
||||
"Task",
|
||||
),
|
||||
),
|
||||
expose_mcps=CLAUDE_MCPS,
|
||||
)
|
||||
|
||||
|
||||
def raycast(name: str, model: str, reasoning_effort: str | None = None) -> RaycastAgent:
|
||||
return RaycastAgent(
|
||||
name=name,
|
||||
model=model,
|
||||
system_prompt=QUICK_PROMPT,
|
||||
reasoning_effort=reasoning_effort,
|
||||
available_native_tools=(RemoteTool.WEB_SEARCH, RemoteTool.READ_PAGE),
|
||||
user_preferences=UserPrefsRu,
|
||||
expose_mcps=(
|
||||
ExposedMcp(name="obsidian-fs"),
|
||||
ExposedMcp(name="firefly", deny=("delete_*",)),
|
||||
ExposedMcp(name="telegram"),
|
||||
*calendar_exposed,
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
agents: list[BaseAgent] = [
|
||||
# §12.D4: диспетчер на medium; high - по руке или в ветке.
|
||||
dispatcher("beaver-dispatcher", "claude-opus-5", effort="medium"),
|
||||
deep("beaver-opus-high", "claude-opus-5", effort="high"),
|
||||
raycast("beaver-gemini-pro-high", "google-gemini-3.1-pro", reasoning_effort="high"),
|
||||
deep("beaver-fable-high", "claude-fable-5", effort="high"),
|
||||
deep("beaver-opus-medium", "claude-opus-5", effort="medium"),
|
||||
deep("beaver-fable-medium", "claude-fable-5", effort="medium"),
|
||||
deep("beaver-opus-xhigh", "claude-opus-5", effort="xhigh"),
|
||||
raycast("beaver-gemini-pro-low", "google-gemini-3.1-pro", reasoning_effort="low"),
|
||||
raycast(
|
||||
"beaver-gemini-flash-high", "google-gemini-3.5-flash", reasoning_effort="high"
|
||||
),
|
||||
raycast(
|
||||
"beaver-gemini-flash-low", "google-gemini-3.5-flash", reasoning_effort="low"
|
||||
),
|
||||
]
|
||||
|
||||
PUBLIC_BASE_URL = os.environ.get("PUBLIC_BASE_URL", "").rstrip("/")
|
||||
|
||||
|
||||
def _public(suffix: str) -> str | None:
|
||||
return f"{PUBLIC_BASE_URL}{suffix}" if PUBLIC_BASE_URL else None
|
||||
|
||||
|
||||
frontends: list[Frontend] = [
|
||||
AnthropicMessagesFrontend(
|
||||
host="0.0.0.0", port=62990, public_base_url=_public("/anthropic")
|
||||
),
|
||||
McpServerFrontend(host="0.0.0.0", port=62991, public_base_url=_public("/mcp")),
|
||||
AdminFrontend(host="0.0.0.0", port=62992, public_base_url=_public("/admin")),
|
||||
# §3.9: /api показывает всё; домашний фронтенд мастера/ветки до S5 - он же,
|
||||
# поэтому дефолтный агент на master/branch живёт здесь, deep - у markdown.
|
||||
ApiFrontend(
|
||||
host="0.0.0.0",
|
||||
port=62994,
|
||||
public_base_url=_public("/api"),
|
||||
master_agent="beaver-dispatcher",
|
||||
branch_agent="beaver-dispatcher",
|
||||
),
|
||||
MarkdownFrontend(
|
||||
host="0.0.0.0",
|
||||
port=62993,
|
||||
vault_path=CHATS_DIR,
|
||||
default_agent="beaver-opus-high",
|
||||
log_all_chats=True,
|
||||
chat_path=chat_path,
|
||||
public_base_url=_public("/md"),
|
||||
),
|
||||
]
|
||||
|
||||
|
||||
def _read(path: Path) -> str | None:
|
||||
return path.read_text(encoding="utf-8").strip() if path.exists() else None
|
||||
|
||||
|
||||
def seed_body(ctx: SeedContext) -> str | None:
|
||||
"""§8.2: утренний сид - вчерашний хендаут из `дни/`; остальные сиды - gateway."""
|
||||
if ctx.seed != "morning":
|
||||
return None
|
||||
yesterday = date.today() - timedelta(days=1)
|
||||
handout = _read(BEAVER / "дни" / f"{yesterday:%Y-%m-%d}.md")
|
||||
return handout or "Хендаут за вчера не приехал."
|
||||
|
||||
|
||||
texts = ConversationTexts(
|
||||
merge_prompt=_read(GRANULES / "слив.md") or ConversationTexts().merge_prompt,
|
||||
seed=seed_body,
|
||||
)
|
||||
|
||||
gateway = Gateway(agents=agents, mcps=mcps, frontends=frontends, texts=texts)
|
||||
+22
-79
@@ -1,12 +1,5 @@
|
||||
x-restart: &restart
|
||||
restart: unless-stopped
|
||||
# Логи контейнеров - не хранилище: держим окно небольшим, чтобы то, что
|
||||
# всё-таки просочилось в stdout, не жило на диске месяцами.
|
||||
logging:
|
||||
driver: json-file
|
||||
options:
|
||||
max-size: "20m"
|
||||
max-file: "3"
|
||||
|
||||
services:
|
||||
postgres:
|
||||
@@ -55,27 +48,27 @@ services:
|
||||
CLAUDE_RUNNER_USER: beaver-runner
|
||||
CLAUDE_HOME: /home/beaver-runner
|
||||
ports:
|
||||
# один порт: /anthropic, /mcp, /admin, /api, /md, / -> админка
|
||||
- "${PORT_GATEWAY:-62990}:62990"
|
||||
- "${PORT_MESSAGES:-62990}:62990" # anthropic
|
||||
- "${PORT_MCP:-62991}:62991" # mcp
|
||||
- "${PORT_ADMIN:-62992}:62992" # admin
|
||||
- "${PORT_MARKDOWN:-62993}:62993" # obsidian companion
|
||||
- "${PORT_API:-62994}:62994" # conversations api + sse
|
||||
volumes:
|
||||
- ./config.py:/config/config.py:ro
|
||||
- ./beaver_agent:/config/beaver_agent:ro
|
||||
- ./config.json:/config/config.json:ro
|
||||
# §3.7: vault - дом диспетчера, rw целиком; границы (`.obsidian`,
|
||||
# `мета` вне `бобер`, удаление чужого) держит policy.py (2026-08-30).
|
||||
- vault:/vault
|
||||
# клон репы комнаты вайбграма (сервис vibegram-repo), только читать
|
||||
- vibegram:/vibegram:ro
|
||||
# §3.7: vault только на чтение, rw - подмонтирования зон агента.
|
||||
- vault:/vault:ro
|
||||
- type: volume
|
||||
source: vault
|
||||
target: /vault/мета/бобер
|
||||
volume:
|
||||
subpath: мета/бобер
|
||||
- type: volume
|
||||
source: vault
|
||||
target: /vault/💬 чаты
|
||||
volume:
|
||||
subpath: 💬 чаты
|
||||
- claude-home:/home/beaver-runner/.claude
|
||||
# Шара на HDD: сюда агент кладёт то, что отдаёт человеку через
|
||||
# send_file (SEND_FILE_ROOTS по умолчанию = /mnt/hole/shared).
|
||||
# Путь СНАРУЖИ И ВНУТРИ ОДИН И ТОТ ЖЕ - модель пишет в тулзу ровно
|
||||
# тот путь, который видит сама. Каталог на хосте принадлежит
|
||||
# 1001:999 - это uid/gid beaver-runner'а внутри, - mode 2770.
|
||||
- /mnt/hole/shared:/mnt/hole/shared
|
||||
extra_hosts:
|
||||
# Home Assistant и прочее с network_mode: host
|
||||
- "host.docker.internal:host-gateway"
|
||||
healthcheck:
|
||||
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:62990/healthz', timeout=3)"]
|
||||
interval: 30s
|
||||
@@ -91,65 +84,15 @@ services:
|
||||
mkdir -p /home/$$runner/.claude
|
||||
[ -e /home/$$runner/.claude/.claude.json ] || echo '{}' > /home/$$runner/.claude/.claude.json
|
||||
chown -R $$runner /home/$$runner
|
||||
# ACL, не chown: Obsidian Sync переписывает файлы под root, а default-ACL
|
||||
# на папках даёт runner'у права и на то, что появится позже.
|
||||
setfacl -R -m "u:$$runner:rwX" -m "d:u:$$runner:rwX" /vault \
|
||||
|| echo "warning: cannot grant $$runner write access to /vault"
|
||||
for d in "/vault/мета/бобер" "/vault/💬 чаты"; do
|
||||
setfacl -R -m "u:$$runner:rwX" -m "d:u:$$runner:rwX" "$$d" \
|
||||
|| chown -R $$runner "$$d" \
|
||||
|| echo "warning: cannot grant $$runner write access to $$d"
|
||||
done
|
||||
exec python -m beaver_gateway
|
||||
|
||||
t3code-mcp:
|
||||
container_name: beaver-t3code-mcp
|
||||
build:
|
||||
context: https://git.kotikot.com/beaver/t3code-mcp.git#${T3CODE_MCP_REF:-main}
|
||||
profiles: [t3]
|
||||
<<: *restart
|
||||
env_file: .env
|
||||
environment:
|
||||
# события тредов (завершён / упал / спрашивает) → инжект в мастер (§4.5)
|
||||
T3CODE_MCP_HOOK_URL: http://gateway:62990/hooks/t3code
|
||||
T3CODE_MCP_STATE: /data/t3code-mcp.json
|
||||
extra_hosts:
|
||||
# tailnet-адрес дев-VM явно, не завися от DNS хоста
|
||||
- "dell-dev:${T3_DELL_DEV_ADDR:?T3_DELL_DEV_ADDR=tailnet ip of dell-dev}"
|
||||
volumes:
|
||||
- ./t3code.toml:/config/t3code.toml:ro
|
||||
- t3code-state:/data
|
||||
|
||||
vibegram-repo:
|
||||
container_name: beaver-vibegram-repo
|
||||
image: alpine/git:latest
|
||||
profiles: [vibegram]
|
||||
<<: *restart
|
||||
env_file: .env
|
||||
volumes:
|
||||
- vibegram:/vibegram
|
||||
# Клон репы комнаты и pull раз в 10 минут. Токен - только заголовком
|
||||
# через GIT_CONFIG_*, в .git/config он не попадает: том читает модель.
|
||||
entrypoint:
|
||||
- /bin/sh
|
||||
- -c
|
||||
- |
|
||||
repo="$${VIBEGRAM_REPO:?VIBEGRAM_REPO=org/repo}"
|
||||
dir="/vibegram/$${repo##*/}"
|
||||
if [ -n "$$VIBEGRAM_REPO_TOKEN" ]; then
|
||||
export GIT_CONFIG_COUNT=1
|
||||
export GIT_CONFIG_KEY_0="http.https://github.com/.extraheader"
|
||||
export GIT_CONFIG_VALUE_0="AUTHORIZATION: basic $$(printf 'x-access-token:%s' "$$VIBEGRAM_REPO_TOKEN" | base64 | tr -d '\n')"
|
||||
fi
|
||||
while true; do
|
||||
if [ -d "$$dir/.git" ]; then
|
||||
git -C "$$dir" pull -q --ff-only || echo "vibegram-repo: pull failed"
|
||||
else
|
||||
git clone -q "https://github.com/$$repo.git" "$$dir" || echo "vibegram-repo: clone failed"
|
||||
fi
|
||||
chmod -R a+rX "$$dir" 2>/dev/null
|
||||
sleep "$${VIBEGRAM_PULL_SECONDS:-600}"
|
||||
done
|
||||
|
||||
volumes:
|
||||
t3code-state:
|
||||
postgres-data:
|
||||
vault:
|
||||
vibegram:
|
||||
obsidian-config:
|
||||
claude-home:
|
||||
@@ -30,13 +30,6 @@ raycast-api = { git = "https://git.kotikot.com/beaver/raycast-api" }
|
||||
|
||||
[dependency-groups]
|
||||
dev = [
|
||||
"pytest>=9.1.1",
|
||||
"pytest-asyncio>=1.4.0",
|
||||
"ruff>=0.15.13",
|
||||
"ty>=0.0.37",
|
||||
]
|
||||
|
||||
[tool.pytest.ini_options]
|
||||
asyncio_mode = "auto"
|
||||
testpaths = ["tests"]
|
||||
pythonpath = ["."]
|
||||
@@ -26,8 +26,6 @@ unfixable = ["F401"]
|
||||
|
||||
[lint.per-file-ignores]
|
||||
"config.py" = ["INP001"]
|
||||
"scripts/split_logs.py" = ["INP001", "T201"]
|
||||
"tests/*" = ["ALL"]
|
||||
|
||||
[lint.pydocstyle]
|
||||
convention = "google"
|
||||
|
||||
@@ -1,510 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# ruff: noqa: E501, EXE001, S603, S108, PLR0915 - одноразовый инструмент, не сервис
|
||||
"""Одноразовый засев памяти агента из истории vault (решение h, 2026-09-01).
|
||||
|
||||
Гоняет `claude -p` на маке (подписка, как бенч) по трём источникам и пишет в
|
||||
локальный vault - Sync донесёт до dell:
|
||||
|
||||
- `💬 чаты/` (не тесты, ещё не в индексе) → выжимка в `мета/бобер/выжимки/`
|
||||
в формате дистиллятора + строка в `индекс.md`, плюс наблюдения по людям;
|
||||
- `📅 дни/` (заполненные, помесячно) → наблюдения по людям и о Бобре;
|
||||
- `🧠 мысли/` (по файлу) → наблюдения, в основном о Бобре.
|
||||
|
||||
Наблюдения - `мета/бобер/наблюдения/<Имя> - наблюдения.md`, строка =
|
||||
`- дата · факт · [[источник]]`; имена только из карточек `👤 люди/` плюс
|
||||
«Бобёр». В карточку добавляется строка `наблюдения: [[Имя - наблюдения]]`.
|
||||
Сырые ответы модели лежат в `scripts/seed_out/` - повторный запуск их
|
||||
переиспользует (resume), файлы vault дописываются без дублей.
|
||||
|
||||
python3 scripts/seed_memory.py --dry-run
|
||||
python3 scripts/seed_memory.py --only chats --limit 2
|
||||
python3 scripts/seed_memory.py # всё
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
from concurrent.futures import ThreadPoolExecutor, as_completed
|
||||
from dataclasses import dataclass
|
||||
from datetime import date
|
||||
from pathlib import Path
|
||||
|
||||
HERE = Path(__file__).resolve().parent
|
||||
sys.path.insert(0, str(HERE.parent))
|
||||
from beaver_gateway.agents.prompts import assemble # noqa: E402
|
||||
|
||||
from beaver_agent.memory.recall import People # noqa: E402
|
||||
|
||||
VAULT = Path.home() / "Documents/obsidian/hh"
|
||||
BEAVER = VAULT / "мета/бобер"
|
||||
CHATS = VAULT / "💬 чаты"
|
||||
DIARY = VAULT / "📅 дни"
|
||||
THOUGHTS = VAULT / "🧠 мысли"
|
||||
PEOPLE = VAULT / "👤 люди"
|
||||
DIGESTS = BEAVER / "выжимки"
|
||||
INDEX = BEAVER / "индекс.md"
|
||||
NOTES = BEAVER / "наблюдения"
|
||||
OUT = HERE / "seed_out"
|
||||
MODEL = "claude-opus-5"
|
||||
MAX_CHARS = 350_000
|
||||
BOBR = "Бобёр"
|
||||
|
||||
PROMPTS = BEAVER / "промпты"
|
||||
GRANULES = PROMPTS / "гранулы"
|
||||
VOICE = tuple(
|
||||
(tag, GRANULES / "голос" / f"{tag}.md")
|
||||
for tag in (
|
||||
"role",
|
||||
"philosophy",
|
||||
"user_profile",
|
||||
"operating_modes",
|
||||
"how_you_operate",
|
||||
"interaction_guidelines",
|
||||
)
|
||||
)
|
||||
# та же сборка, что у мастера в config.py, только окружение - джоб
|
||||
SEED_BUILD = (
|
||||
*VOICE,
|
||||
("profile", PROMPTS / "профиль.md"),
|
||||
("corrections", PROMPTS / "поправки.md"),
|
||||
("vault_map", GRANULES / "карта-vault.md"),
|
||||
("environment", GRANULES / "окружения" / "джоб.md"),
|
||||
("dispatcher", GRANULES / "диспетчер.md"),
|
||||
)
|
||||
|
||||
DIGEST_MARK = "=== ВЫЖИМКА ==="
|
||||
NOTES_MARK = "=== НАБЛЮДЕНИЯ ==="
|
||||
END_MARK = "=== КОНЕЦ ==="
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Source:
|
||||
kind: str # chats | days | thoughts
|
||||
id: str # имя для seed_out и [[ссылки]]
|
||||
title: str
|
||||
text: str
|
||||
when: str # дата источника YYYY-MM-DD (для наблюдений без даты в тексте)
|
||||
link: str # что ставить в [[...]] у наблюдений
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- prompts --
|
||||
|
||||
|
||||
def system_prompt(names: list[str]) -> str:
|
||||
"""Настоящие гранулы Менеджера Бобрения + блок задания на засев."""
|
||||
distiller = (GRANULES / "дистиллятор.md").read_text(encoding="utf-8")
|
||||
keep = distiller[distiller.find("Что сохранять:") :].strip()
|
||||
known = ", ".join(names)
|
||||
seed = f"""Это засев памяти, одноразовый джоб (решение Бобра, 2026-09-01): тебе по одному отдают
|
||||
документы из истории vault - старые чаты с тобой, месяцы дневника, заметки-мысли, - и ты
|
||||
отдаёшь то, что из них должно остаться у тебя в памяти. Тулз нет, файлы запишет gateway из
|
||||
твоего ответа. Ответ - строго в формате ниже, ничего вне маркеров.
|
||||
|
||||
{DIGEST_MARK}
|
||||
(только для чата; для дневника и мысли блок пропускается целиком)
|
||||
# тема
|
||||
## контекст
|
||||
2-4 строки: зачем открывали.
|
||||
## решили
|
||||
- решения и их причины; цифры, имена, даты, [[ссылки]] дословно
|
||||
## открытые вопросы
|
||||
- что не закрыто
|
||||
## ссылки
|
||||
- [[люди]], [[проекты]], соседние чаты - только реально упомянутые
|
||||
{NOTES_MARK}
|
||||
Имя :: YYYY-MM-DD · факт
|
||||
{END_MARK}
|
||||
|
||||
Выжимка - по правилам дистиллятора: нейтральный язык, третье лицо («Бобёр решил»), без
|
||||
мнения, которого в разговоре не было. {keep}
|
||||
|
||||
Наблюдения - твои записки из блока «Память» оверлея: то, чего нет в vault и что понадобится,
|
||||
чтобы заметить повтор - реакция человека, отговорка, обещание, оценка, состояние, паттерн,
|
||||
событие в отношениях. Не биография и не пересказ карточки (возраст, где живёт), не общие слова.
|
||||
Имя - ровно одно из списка ниже, как написано, или «{BOBR}» для самого Бобра; людей не из
|
||||
списка не записывай. Дата - из текста, если она там есть, иначе дата документа. Одна строка,
|
||||
до 200 знаков, коротко и по факту; на человека до 6 строк с документа, на {BOBR} - до 12.
|
||||
Нет наблюдений - блок пустой.
|
||||
|
||||
Известные имена: {known}"""
|
||||
parts = list(SEED_BUILD)
|
||||
text = assemble(parts)
|
||||
return f"{text}\n<seed>\n{seed}\n</seed>\n"
|
||||
|
||||
|
||||
def user_prompt(src: Source) -> str:
|
||||
what = {
|
||||
"chats": "чат с агентом",
|
||||
"days": "месяц дневника",
|
||||
"thoughts": "заметка-мысль",
|
||||
}[src.kind]
|
||||
return f"Документ: {what}, «{src.title}», дата {src.when}.\n\n{src.text}"
|
||||
|
||||
|
||||
# ---------------------------------------------------------------- sources --
|
||||
|
||||
CALLOUT_RE = re.compile(r"^> \[!(tool|thinking)\]")
|
||||
|
||||
|
||||
def strip_chat(text: str) -> str:
|
||||
"""Без фронтматтера, тул-коллов и thinking: только реплики."""
|
||||
if text.startswith("---"):
|
||||
end = text.find("\n---", 3)
|
||||
if end > 0:
|
||||
text = text[end + 4 :]
|
||||
out: list[str] = []
|
||||
skipping = False
|
||||
for line in text.splitlines():
|
||||
if CALLOUT_RE.match(line):
|
||||
skipping = True
|
||||
continue
|
||||
if skipping and line.startswith(">"):
|
||||
continue
|
||||
skipping = False
|
||||
out.append(line)
|
||||
cleaned = re.sub(r"\n{3,}", "\n\n", "\n".join(out)).strip()
|
||||
return cleaned[:MAX_CHARS]
|
||||
|
||||
|
||||
def indexed_chats() -> set[str]:
|
||||
if not INDEX.exists():
|
||||
return set()
|
||||
return set(re.findall(r"\[\[([^\]]+)\]\] →", INDEX.read_text(encoding="utf-8")))
|
||||
|
||||
|
||||
def chat_sources() -> list[Source]:
|
||||
done = indexed_chats()
|
||||
out: list[Source] = []
|
||||
for path in sorted(CHATS.rglob("*.md")):
|
||||
if (
|
||||
"тест" in path.stem.lower()
|
||||
or path.stat().st_size < 5_000
|
||||
or path.stem in done
|
||||
):
|
||||
continue
|
||||
text = strip_chat(path.read_text(encoding="utf-8", errors="ignore"))
|
||||
if len(text) < 1_500:
|
||||
continue
|
||||
when = (
|
||||
path.stem[:10]
|
||||
if re.match(r"\d{4}-\d{2}-\d{2}", path.stem)
|
||||
else date.today().isoformat()
|
||||
)
|
||||
out.append(
|
||||
Source("chats", f"chat_{path.stem}", path.stem, text, when, path.stem)
|
||||
)
|
||||
return out
|
||||
|
||||
|
||||
def day_sources() -> list[Source]:
|
||||
months: dict[str, list[Path]] = {}
|
||||
for path in sorted(DIARY.glob("????-??-??.md")):
|
||||
if path.stat().st_size > 700:
|
||||
months.setdefault(path.stem[:7], []).append(path)
|
||||
out: list[Source] = []
|
||||
for month, files in sorted(months.items()):
|
||||
parts = []
|
||||
for f in files:
|
||||
body = f.read_text(encoding="utf-8", errors="ignore")
|
||||
body = body.split("\n# планы", 1)[0] # хвост с tasks-запросами
|
||||
parts.append(f"### [[{f.stem}]]\n{body.strip()}")
|
||||
text = "\n\n".join(parts)[:MAX_CHARS]
|
||||
out.append(
|
||||
Source(
|
||||
"days",
|
||||
f"days_{month}",
|
||||
f"дневник {month}",
|
||||
text,
|
||||
f"{month}-01",
|
||||
"дневник",
|
||||
)
|
||||
)
|
||||
return out
|
||||
|
||||
|
||||
def thought_sources() -> list[Source]:
|
||||
out: list[Source] = []
|
||||
for path in sorted(THOUGHTS.rglob("*.md")):
|
||||
if path.stat().st_size < 400:
|
||||
continue
|
||||
m = re.match(r"(\d{4}-\d{2}-\d{2})", path.stem)
|
||||
when = m.group(1) if m else date.today().isoformat()
|
||||
text = path.read_text(encoding="utf-8", errors="ignore")[:MAX_CHARS]
|
||||
out.append(
|
||||
Source("thoughts", f"thought_{path.stem}", path.stem, text, when, path.stem)
|
||||
)
|
||||
return out
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ model --
|
||||
|
||||
|
||||
def _result(payload: str) -> dict:
|
||||
"""`claude -p --output-format json` отдаёт либо объект, либо массив сообщений."""
|
||||
data = json.loads(payload)
|
||||
if isinstance(data, list):
|
||||
results = [x for x in data if isinstance(x, dict) and x.get("type") == "result"]
|
||||
return results[-1] if results else {}
|
||||
return data if isinstance(data, dict) else {}
|
||||
|
||||
|
||||
def ask(src: Source, system: str) -> str:
|
||||
raw = OUT / f"{src.id}.json"
|
||||
if raw.exists():
|
||||
try:
|
||||
data = _result(raw.read_text(encoding="utf-8"))
|
||||
except json.JSONDecodeError:
|
||||
data = {}
|
||||
if data.get("result") and not data.get("is_error"):
|
||||
return data["result"]
|
||||
cmd = [
|
||||
"claude",
|
||||
"-p",
|
||||
user_prompt(src),
|
||||
"--system-prompt",
|
||||
system,
|
||||
"--model",
|
||||
MODEL,
|
||||
"--effort",
|
||||
"medium",
|
||||
"--tools",
|
||||
"",
|
||||
"--setting-sources",
|
||||
"",
|
||||
"--strict-mcp-config",
|
||||
"--disable-slash-commands",
|
||||
"--no-session-persistence",
|
||||
"--output-format",
|
||||
"json",
|
||||
]
|
||||
proc = subprocess.run(
|
||||
cmd, capture_output=True, text=True, timeout=1200, cwd="/tmp", check=False
|
||||
)
|
||||
OUT.mkdir(exist_ok=True)
|
||||
raw.write_text(
|
||||
proc.stdout or json.dumps({"error": proc.stderr[-2000:]}), encoding="utf-8"
|
||||
)
|
||||
if proc.returncode != 0 or not proc.stdout:
|
||||
msg = f"{src.id}: claude exit {proc.returncode}: {proc.stderr[-500:]}"
|
||||
raise RuntimeError(msg)
|
||||
data = _result(proc.stdout)
|
||||
if data.get("is_error") or not data.get("result"):
|
||||
msg = f"{src.id}: {data.get('result') or data}"
|
||||
raise RuntimeError(msg)
|
||||
return data["result"]
|
||||
|
||||
|
||||
def parse(answer: str) -> tuple[str | None, list[tuple[str, str, str]]]:
|
||||
digest = None
|
||||
if DIGEST_MARK in answer and NOTES_MARK in answer:
|
||||
digest = answer.split(DIGEST_MARK, 1)[1].split(NOTES_MARK, 1)[0].strip() or None
|
||||
if digest and digest.startswith("("): # «(только для чата ...)» пропуск
|
||||
digest = None
|
||||
notes_part = answer.split(NOTES_MARK, 1)[1] if NOTES_MARK in answer else ""
|
||||
notes_part = notes_part.split(END_MARK, 1)[0]
|
||||
notes: list[tuple[str, str, str]] = []
|
||||
for line in notes_part.splitlines():
|
||||
m = re.match(
|
||||
r"^\s*-?\s*(.+?)\s*::\s*(\d{4}-\d{2}-\d{2})\s*[·\-]\s*(.+?)\s*$", line
|
||||
)
|
||||
if m:
|
||||
notes.append((m.group(1).strip(), m.group(2), m.group(3).strip()))
|
||||
return digest, notes
|
||||
|
||||
|
||||
# ------------------------------------------------------------------ write --
|
||||
|
||||
SLUG_BAD = re.compile(r"[^\w\s-]", re.UNICODE)
|
||||
|
||||
|
||||
def slugify(text: str, maxlen: int = 40) -> str:
|
||||
cleaned = re.sub(r"[\s-]+", "-", SLUG_BAD.sub(" ", text).strip()).strip("-")
|
||||
return cleaned[:maxlen].rstrip("-") or "untitled"
|
||||
|
||||
|
||||
def write_digest(src: Source, body: str, today: str) -> str:
|
||||
DIGESTS.mkdir(parents=True, exist_ok=True)
|
||||
stem = f"{today} - {slugify(src.title)}"
|
||||
path = DIGESTS / f"{stem}.md"
|
||||
n = 2
|
||||
while path.exists() and f"[[{src.title}]]" not in path.read_text(encoding="utf-8"):
|
||||
path = DIGESTS / f"{stem} ({n}).md"
|
||||
n += 1
|
||||
path.write_text(
|
||||
f'---\ntype: выжимка\nsource: "[[{src.title}]]"\ndate: {today}\n---\n\n{body.strip()}\n',
|
||||
encoding="utf-8",
|
||||
)
|
||||
line = f"- {today} [[{src.title}]] → [[{path.stem}]]"
|
||||
text = (
|
||||
INDEX.read_text(encoding="utf-8")
|
||||
if INDEX.exists()
|
||||
else "# индекс\n\nстрока на выжимку: чат → его выжимка.\n"
|
||||
)
|
||||
if line not in text.splitlines():
|
||||
INDEX.write_text(text.rstrip("\n") + "\n" + line + "\n", encoding="utf-8")
|
||||
return path.stem
|
||||
|
||||
|
||||
def note_file(name: str) -> Path:
|
||||
return NOTES / f"{name} - наблюдения.md"
|
||||
|
||||
|
||||
def append_notes(name: str, lines: list[str]) -> int:
|
||||
NOTES.mkdir(parents=True, exist_ok=True)
|
||||
path = note_file(name)
|
||||
if not path.exists():
|
||||
path.write_text(
|
||||
f"# {name} - наблюдения\n\n> папка терапевта: пишет менеджер бобрения. "
|
||||
"Строка = дата · факт · источник. Бобёр по умолчанию не читает, но может.\n\n",
|
||||
encoding="utf-8",
|
||||
)
|
||||
existing = set(path.read_text(encoding="utf-8").splitlines())
|
||||
fresh = [ln for ln in lines if ln not in existing]
|
||||
if fresh:
|
||||
with path.open("a", encoding="utf-8") as fh:
|
||||
fh.write("\n".join(fresh) + "\n")
|
||||
return len(fresh)
|
||||
|
||||
|
||||
def sort_notes() -> None:
|
||||
"""Сортирует и дедупит только `## лента`; шапку (сейчас/паттерны/…) не трогает."""
|
||||
for path in NOTES.glob("* - наблюдения.md"):
|
||||
text = path.read_text(encoding="utf-8")
|
||||
head_text, sep, feed = text.partition("## лента\n")
|
||||
bullets = [ln for ln in feed.splitlines() if ln.startswith("- ")]
|
||||
bullets = sorted(dict.fromkeys(bullets), key=lambda ln: ln[2:12])
|
||||
if not sep:
|
||||
head_text = head_text.rstrip("\n") + "\n\n"
|
||||
head_text = head_text.replace("\n- ", "\n").rstrip() + "\n\n"
|
||||
path.write_text(
|
||||
head_text.rstrip("\n") + "\n\n## лента\n" + "\n".join(bullets) + "\n",
|
||||
encoding="utf-8",
|
||||
)
|
||||
|
||||
|
||||
def link_card(person_path: Path, name: str) -> bool:
|
||||
text = person_path.read_text(encoding="utf-8")
|
||||
link = f"[[{name} - наблюдения]]"
|
||||
if link in text:
|
||||
return False
|
||||
person_path.write_text(
|
||||
text.rstrip("\n") + f"\n\nнаблюдения: {link}\n", encoding="utf-8"
|
||||
)
|
||||
return True
|
||||
|
||||
|
||||
# ------------------------------------------------------------------- main --
|
||||
|
||||
|
||||
def main() -> None:
|
||||
ap = argparse.ArgumentParser()
|
||||
ap.add_argument("--only", choices=["chats", "days", "thoughts"])
|
||||
ap.add_argument("--limit", type=int)
|
||||
ap.add_argument("--dry-run", action="store_true")
|
||||
ap.add_argument("--jobs", type=int, default=4)
|
||||
ap.add_argument("--pick", help="подстрока в названии источника")
|
||||
args = ap.parse_args()
|
||||
|
||||
# хабы групп («бывшие», «рандомы») - не люди, наблюдения им не пишем
|
||||
people = [
|
||||
p for p in People(PEOPLE, VAULT, ttl=10_000).all() if "/группы/" not in p.path
|
||||
]
|
||||
by_name = {p.name: p for p in people}
|
||||
for p in people: # алиасы тоже принимаем, но пишем под именем карточки
|
||||
for a in p.aliases:
|
||||
by_name.setdefault(a, p)
|
||||
names = sorted(p.name for p in people)
|
||||
system = system_prompt(names)
|
||||
|
||||
sources: list[Source] = []
|
||||
if args.only in (None, "chats"):
|
||||
sources += chat_sources()
|
||||
if args.only in (None, "days"):
|
||||
sources += day_sources()
|
||||
if args.only in (None, "thoughts"):
|
||||
sources += thought_sources()
|
||||
if args.pick:
|
||||
sources = [s for s in sources if args.pick.lower() in s.title.lower()]
|
||||
if args.limit:
|
||||
sources = sources[: args.limit]
|
||||
total_chars = sum(len(s.text) for s in sources)
|
||||
print(
|
||||
f"источников: {len(sources)}, символов: {total_chars:,} (~{total_chars // 3.5:,.0f} токенов)"
|
||||
)
|
||||
for s in sources:
|
||||
print(f" {s.kind:8} {s.title[:60]:60} {len(s.text):>8}")
|
||||
if args.dry_run:
|
||||
return
|
||||
|
||||
today = date.today().isoformat()
|
||||
written: dict[str, int] = {}
|
||||
linked: list[str] = []
|
||||
failures: list[str] = []
|
||||
with ThreadPoolExecutor(max_workers=args.jobs) as pool:
|
||||
futs = {pool.submit(ask, s, system): s for s in sources}
|
||||
for fut in as_completed(futs):
|
||||
src = futs[fut]
|
||||
try:
|
||||
answer = fut.result()
|
||||
except Exception as exc: # noqa: BLE001
|
||||
failures.append(str(exc))
|
||||
print(f"FAIL {src.id}: {exc}"[:300])
|
||||
continue
|
||||
digest, notes = parse(answer)
|
||||
digest_stem = (
|
||||
write_digest(src, digest, today)
|
||||
if src.kind == "chats" and digest
|
||||
else None
|
||||
)
|
||||
grouped: dict[str, list[str]] = {}
|
||||
unknown: set[str] = set()
|
||||
for raw_name, when, fact in notes:
|
||||
name = (
|
||||
BOBR
|
||||
if raw_name.casefold() in (BOBR.casefold(), "бобер", "h", "андрей")
|
||||
else None
|
||||
)
|
||||
if name is None:
|
||||
person = by_name.get(raw_name)
|
||||
if person is None:
|
||||
unknown.add(raw_name)
|
||||
continue
|
||||
name = person.name
|
||||
link = f"[[{src.link}]]" if src.kind != "days" else ""
|
||||
if src.kind == "days":
|
||||
link = (
|
||||
f"[[{when}]]"
|
||||
if (DIARY / f"{when}.md").exists()
|
||||
else "[[дневник]]"
|
||||
)
|
||||
grouped.setdefault(name, []).append(f"- {when} · {fact} · {link}")
|
||||
for name, lines in grouped.items():
|
||||
n = append_notes(name, lines)
|
||||
written[name] = written.get(name, 0) + n
|
||||
if (
|
||||
name != BOBR
|
||||
and name in by_name
|
||||
and link_card(VAULT / by_name[name].path, name)
|
||||
):
|
||||
linked.append(name)
|
||||
print(
|
||||
f"ok {src.id}: digest={digest_stem or '-'} notes={sum(len(v) for v in grouped.values())}"
|
||||
+ (f" unknown={sorted(unknown)}" if unknown else "")
|
||||
)
|
||||
sort_notes()
|
||||
print("\nнаблюдений добавлено по людям:")
|
||||
for name, n in sorted(written.items(), key=lambda kv: -kv[1]):
|
||||
print(f" {n:4} {name}")
|
||||
if linked:
|
||||
print("ссылка добавлена в карточки:", ", ".join(sorted(set(linked))))
|
||||
if failures:
|
||||
print(f"\nошибок: {len(failures)}")
|
||||
sys.exit(1)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,283 +0,0 @@
|
||||
"""Разовая нарезка вечных и месячных файлов `мета/бобер/` по дням.
|
||||
|
||||
BEAVER_VAULT=<vault> PYTHONPATH=. uv run python scripts/split_logs.py
|
||||
BEAVER_VAULT=<vault> PYTHONPATH=. uv run python scripts/split_logs.py --apply
|
||||
|
||||
Без `--apply` только печатает, что будет.
|
||||
|
||||
Реплики и журнал куратора режутся точно: дата стоит в каждой записи. Дневник
|
||||
режется по заголовкам и датированным строкам: записи под заголовком едут в
|
||||
`дневник/`, строки вида `- 05:4x 12.10 …` - в `журнал/`. Журнал досуга на две
|
||||
трети без дат, поэтому уезжает одним архивом. Оригиналы копируются в
|
||||
`мета/бобер/.архив/<сегодня>/` до первой записи.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
import shutil
|
||||
import sys
|
||||
from collections import defaultdict
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import date, timedelta
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from beaver_agent.vault import (
|
||||
BEAVER,
|
||||
CURATOR_JOURNAL,
|
||||
CURATOR_RUNS,
|
||||
JOURNAL,
|
||||
LEISURE,
|
||||
OWN_DIARY,
|
||||
REPLIES,
|
||||
VAULT,
|
||||
today,
|
||||
)
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from pathlib import Path
|
||||
|
||||
YEAR = 2026
|
||||
OLD_DIARY = BEAVER / "дневник.md"
|
||||
LEISURE_ARCHIVE = JOURNAL / "архив досуга.md"
|
||||
|
||||
REPLY = re.compile(r"^- (\d{4}-\d{2}-\d{2}) \d{2}:\d{2} · ")
|
||||
RUN = re.compile(r"^## (\d{4}-\d{2}-\d{2})\b")
|
||||
ISO_HEAD = re.compile(r"^#{2,3}\s+(\d{4})-(\d{2})-(\d{2})\b")
|
||||
HEAD = re.compile(r"^#{2,3}\s")
|
||||
HEAD_DAY = re.compile(r"\b(\d{2})\.(\d{2})\b")
|
||||
HEAD_HOUR = re.compile(r"^#{2,3}\s+(\d{2}):[\dx]{2}")
|
||||
LINE = re.compile(r"^- (\d{2}):[\dx]{2}(?:-\d{2}:[\dx]{2})? (\d{2})\.(\d{2})\b")
|
||||
LINE_DAY_FIRST = re.compile(r"^- (\d{2})\.(\d{2}) (\d{2}):[\dx]{2}\b")
|
||||
|
||||
CURATOR_STUB = (
|
||||
"\n# куратор\n\n"
|
||||
"> Здесь только строка прошлого прогона. Записи прогонов - в "
|
||||
"`куратор/YYYY-MM-DD.md`, файл на день, свежие сверху.\n"
|
||||
)
|
||||
DIARY_STUB = (
|
||||
"\n---\n\n"
|
||||
"> С 13.10.2026 дневник лежит по дням: `дневник/YYYY-MM-DD.md` - то, что "
|
||||
"я думаю; следы тиков, логи и разбор промахов - `журнал/YYYY-MM-DD.md`. "
|
||||
"Сюда больше не дописывать.\n"
|
||||
)
|
||||
|
||||
|
||||
@dataclass
|
||||
class Plan:
|
||||
writes: dict[Path, str] = field(default_factory=dict)
|
||||
removes: list[Path] = field(default_factory=list)
|
||||
backups: list[Path] = field(default_factory=list)
|
||||
notes: list[str] = field(default_factory=list)
|
||||
|
||||
def note(self, text: str) -> None:
|
||||
self.notes.append(text)
|
||||
|
||||
|
||||
def _join(blocks: list[str], sep: str) -> str:
|
||||
return sep.join(block.strip("\n") for block in blocks if block.strip()) + "\n"
|
||||
|
||||
|
||||
def _merge(path: Path, old: str, *, old_first: bool) -> str:
|
||||
"""Старое рядом с тем, что уже успели положить в файл дня."""
|
||||
if not path.exists():
|
||||
return old
|
||||
fresh = path.read_text(encoding="utf-8").rstrip("\n") + "\n"
|
||||
return f"{old}\n{fresh}" if old_first else f"{fresh}\n{old}"
|
||||
|
||||
|
||||
def split_replies(plan: Plan) -> None:
|
||||
for month in sorted(REPLIES.glob("????-??.md")):
|
||||
days: dict[str, list[str]] = defaultdict(list)
|
||||
stray = 0
|
||||
for line in month.read_text(encoding="utf-8").splitlines():
|
||||
match = REPLY.match(line)
|
||||
if match:
|
||||
days[match.group(1)].append(line)
|
||||
elif line.strip() and not line.startswith(("#", ">")):
|
||||
stray += 1
|
||||
for day, lines in days.items():
|
||||
path = REPLIES / f"{day}.md"
|
||||
known = (
|
||||
[
|
||||
line
|
||||
for line in path.read_text(encoding="utf-8").splitlines()
|
||||
if REPLY.match(line)
|
||||
]
|
||||
if path.exists()
|
||||
else []
|
||||
)
|
||||
seen = set(lines)
|
||||
merged = sorted(
|
||||
[*lines, *(line for line in known if line not in seen)],
|
||||
key=lambda line: line[:18],
|
||||
)
|
||||
plan.writes[path] = (
|
||||
f"# реплики Бобра, {day}\n\n"
|
||||
"> пишет gateway: что Бобёр сказал в мастере и ветках, "
|
||||
"строка на сообщение. Глубокие чаты лежат в `💬 чаты/` сами.\n\n"
|
||||
+ "\n".join(merged)
|
||||
+ "\n"
|
||||
)
|
||||
plan.removes.append(month)
|
||||
plan.backups.append(month)
|
||||
plan.note(
|
||||
f"{month.name}: {sum(map(len, days.values()))} реплик на {len(days)} дней"
|
||||
+ (f", {stray} строк без даты пропали" if stray else "")
|
||||
)
|
||||
|
||||
|
||||
def split_curator(plan: Plan) -> None:
|
||||
if not CURATOR_JOURNAL.exists():
|
||||
return
|
||||
lines = CURATOR_JOURNAL.read_text(encoding="utf-8").splitlines()
|
||||
days: dict[str, list[str]] = defaultdict(list)
|
||||
runs: list[str] | None = None
|
||||
for line in lines:
|
||||
match = RUN.match(line)
|
||||
if match:
|
||||
runs = days[match.group(1)]
|
||||
runs.append(line)
|
||||
elif runs is not None:
|
||||
runs[-1] += "\n" + line
|
||||
if not days:
|
||||
return
|
||||
for day, entries in days.items():
|
||||
path = CURATOR_RUNS / f"{day}.md"
|
||||
plan.writes[path] = _merge(path, _join(entries, "\n\n"), old_first=False)
|
||||
plan.writes[CURATOR_JOURNAL] = lines[0] + "\n" + CURATOR_STUB
|
||||
plan.backups.append(CURATOR_JOURNAL)
|
||||
plan.note(
|
||||
f"{CURATOR_JOURNAL.name}: {sum(map(len, days.values()))} прогонов "
|
||||
f"на {len(days)} дней"
|
||||
)
|
||||
|
||||
|
||||
def _day(month: str, day: str) -> date:
|
||||
return date(YEAR, int(month), int(day))
|
||||
|
||||
|
||||
def split_diary(plan: Plan) -> None:
|
||||
if not OLD_DIARY.exists():
|
||||
return
|
||||
lines = OLD_DIARY.read_text(encoding="utf-8").splitlines()
|
||||
first = next((i for i, line in enumerate(lines) if HEAD.match(line)), len(lines))
|
||||
preamble = "\n".join(lines[:first]).rstrip().removesuffix("---").rstrip()
|
||||
thoughts: dict[date, list[str]] = defaultdict(list)
|
||||
traces: dict[date, list[str]] = defaultdict(list)
|
||||
current: date | None = None
|
||||
hour = 0
|
||||
chunk: list[str] | None = None
|
||||
for number, line in enumerate(lines[first:], first + 1):
|
||||
iso, timed = ISO_HEAD.match(line), HEAD_HOUR.match(line)
|
||||
log = LINE.match(line)
|
||||
day_first = LINE_DAY_FIRST.match(line)
|
||||
stamp: date | None = None
|
||||
target = thoughts
|
||||
if iso:
|
||||
stamp = date(int(iso.group(1)), int(iso.group(2)), int(iso.group(3)))
|
||||
elif HEAD.match(line):
|
||||
named = HEAD_DAY.search(line)
|
||||
if named:
|
||||
stamp = _day(named.group(2), named.group(1))
|
||||
elif timed and current is not None:
|
||||
rolled = int(timed.group(1)) < hour
|
||||
stamp = current + timedelta(days=1) if rolled else current
|
||||
if timed:
|
||||
hour = int(timed.group(1))
|
||||
elif log:
|
||||
stamp, target = _day(log.group(3), log.group(2)), traces
|
||||
elif day_first:
|
||||
stamp, target = _day(day_first.group(2), day_first.group(1)), traces
|
||||
if stamp is None:
|
||||
if chunk is not None:
|
||||
chunk[-1] += "\n" + line
|
||||
continue
|
||||
if current is not None and stamp < current:
|
||||
plan.note(f"дневник, строка {number}: дата идёт назад, {current} → {stamp}")
|
||||
current = stamp
|
||||
chunk = target[stamp]
|
||||
chunk.append(line)
|
||||
if not thoughts and not traces:
|
||||
return
|
||||
for day, blocks in thoughts.items():
|
||||
path = OWN_DIARY / f"{day}.md"
|
||||
plan.writes[path] = _merge(path, _join(blocks, "\n\n"), old_first=True)
|
||||
for day, blocks in traces.items():
|
||||
path = JOURNAL / f"{day}.md"
|
||||
plan.writes[path] = _merge(path, _join(blocks, "\n"), old_first=True)
|
||||
plan.writes[OLD_DIARY] = preamble + "\n" + DIARY_STUB
|
||||
plan.backups.append(OLD_DIARY)
|
||||
plan.note(
|
||||
f"{OLD_DIARY.name}: {sum(map(len, thoughts.values()))} записей на "
|
||||
f"{len(thoughts)} дней в дневник, {sum(map(len, traces.values()))} строк на "
|
||||
f"{len(traces)} дней в журнал"
|
||||
)
|
||||
|
||||
|
||||
def split_leisure(plan: Plan) -> None:
|
||||
if not LEISURE.exists():
|
||||
return
|
||||
text = LEISURE.read_text(encoding="utf-8")
|
||||
head, mark, journal = text.partition("\n## журнал\n")
|
||||
if not mark or not journal.strip():
|
||||
return
|
||||
plan.writes[LEISURE_ARCHIVE] = (
|
||||
"# журнал досуга до 13.10.2026\n\n"
|
||||
"> Архив из `досуг.md`: записи шли без дат и в разном порядке, по дням "
|
||||
"их не разложить. Дальше следы тиков лежат в `журнал/YYYY-MM-DD.md`.\n\n"
|
||||
+ journal.strip("\n")
|
||||
+ "\n"
|
||||
)
|
||||
plan.writes[LEISURE] = head.rstrip("\n") + "\n"
|
||||
plan.backups.append(LEISURE)
|
||||
plan.note(
|
||||
f"{LEISURE.name}: {len(journal) // 1024} КБ журнала в архив, "
|
||||
f"в файле остаётся {len(head) // 1024 + 1} КБ раскладки"
|
||||
)
|
||||
|
||||
|
||||
def backup(sources: list[Path]) -> Path:
|
||||
target = BEAVER / ".архив" / today()
|
||||
target.mkdir(parents=True, exist_ok=True)
|
||||
for path in sources:
|
||||
if path.exists() and not (target / path.name).exists():
|
||||
shutil.copy2(path, target / path.name)
|
||||
return target
|
||||
|
||||
|
||||
def main() -> None:
|
||||
plan = Plan()
|
||||
split_replies(plan)
|
||||
split_curator(plan)
|
||||
split_diary(plan)
|
||||
split_leisure(plan)
|
||||
for note in plan.notes:
|
||||
print(note)
|
||||
folders: dict[str, int] = defaultdict(int)
|
||||
for path in plan.writes:
|
||||
folders[str(path.parent.relative_to(VAULT))] += 1
|
||||
for folder, count in sorted(folders.items()):
|
||||
print(f"{folder}: {count} файлов")
|
||||
largest = max(plan.writes.items(), key=lambda item: len(item[1]), default=None)
|
||||
if largest:
|
||||
print(
|
||||
f"самый большой: {largest[0].relative_to(VAULT)}, "
|
||||
f"{len(largest[1].encode()) // 1024} КБ"
|
||||
)
|
||||
if "--apply" not in sys.argv:
|
||||
print("ничего не записано: это прогон без --apply")
|
||||
return
|
||||
if not plan.writes:
|
||||
return
|
||||
print(f"оригиналы: {backup(plan.backups).relative_to(VAULT)}")
|
||||
for path, text in plan.writes.items():
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_text(text, encoding="utf-8")
|
||||
for path in plan.removes:
|
||||
path.unlink()
|
||||
print(f"записано {len(plan.writes)} файлов, убрано {len(plan.removes)}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,87 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
"""Войти в комнату вайбграма по коду приглашения и получить токен агента.
|
||||
|
||||
Обычный путь - CLI `vibegram join <code> --nick <ник> --no-hooks` из клона
|
||||
репы комнаты. Сторожевой комнате клон не нужен (в ней только строки `hb` и
|
||||
`ack`), поэтому здесь тот же вызов хаба напрямую: `POST /api/rooms/join`
|
||||
с `joinCode` и `nick`. Ответ печатается целиком - токен из него едет в
|
||||
`.env` как `VIBEGRAM_HB_TOKEN`, после чего gateway надо перезапустить.
|
||||
|
||||
python3 scripts/vibegram_join.py <join-code> --nick <ник>
|
||||
python3 scripts/vibegram_join.py <join-code> --hub https://vibegram.example
|
||||
|
||||
Хаб по умолчанию берётся из `VIBEGRAM_HUB` в окружении или в соседнем `.env`.
|
||||
Токен печатается в терминал - не вставляй вывод в чаты и в задачи.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
from pathlib import Path
|
||||
|
||||
ENV = Path(__file__).resolve().parent.parent / ".env"
|
||||
USER_AGENT = "beaver-agent/0.1 (+vibegram)"
|
||||
|
||||
|
||||
def hub_from_env() -> str | None:
|
||||
if os.environ.get("VIBEGRAM_HUB"):
|
||||
return os.environ["VIBEGRAM_HUB"]
|
||||
if not ENV.exists():
|
||||
return None
|
||||
for line in ENV.read_text(encoding="utf-8").splitlines():
|
||||
key, _, value = line.partition("=")
|
||||
if key.strip() == "VIBEGRAM_HUB" and value.strip():
|
||||
return value.strip()
|
||||
return None
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("code", help="код приглашения из комнаты")
|
||||
parser.add_argument("--nick", help="ник агента в этой комнате")
|
||||
parser.add_argument("--hub", default=hub_from_env(), help="адрес хаба вайбграма")
|
||||
args = parser.parse_args()
|
||||
if not args.hub:
|
||||
print("не знаю адрес хаба: задай --hub или VIBEGRAM_HUB", file=sys.stderr)
|
||||
return 2
|
||||
|
||||
body: dict[str, str] = {"joinCode": args.code}
|
||||
if args.nick:
|
||||
body["nick"] = args.nick
|
||||
request = urllib.request.Request( # noqa: S310 - адрес хаба задаёт оператор
|
||||
f"{args.hub.rstrip('/')}/api/rooms/join",
|
||||
data=json.dumps(body).encode(),
|
||||
# Перед хабом Cloudflare: безымянный `Python-urllib` он отбивает 1010.
|
||||
# Тот же user-agent, что у клиента в `beaver_agent/hands/vibegram.py`.
|
||||
headers={"content-type": "application/json", "user-agent": USER_AGENT},
|
||||
method="POST",
|
||||
)
|
||||
try:
|
||||
with urllib.request.urlopen(request, timeout=20) as response: # noqa: S310
|
||||
data = json.loads(response.read())
|
||||
except urllib.error.HTTPError as exc:
|
||||
print(f"хаб отказал: {exc.code} {exc.read().decode()[:400]}", file=sys.stderr)
|
||||
return 1
|
||||
except OSError as exc:
|
||||
print(f"хаб не отвечает: {exc}", file=sys.stderr)
|
||||
return 1
|
||||
|
||||
print(json.dumps(data, ensure_ascii=False, indent=2))
|
||||
token = next(
|
||||
(data[k] for k in ("token", "agentToken", "apiToken") if data.get(k)), None
|
||||
)
|
||||
if token:
|
||||
print(f"\nVIBEGRAM_HB_TOKEN={token}\n\nдальше: строку в .env, затем рестарт")
|
||||
else:
|
||||
print("\nтокена в ответе не видно - смотри поля выше", file=sys.stderr)
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
-17
@@ -1,17 +0,0 @@
|
||||
# Машины с T3 Code и allowlist проектов на каждой. Токены - в .env (T3_*_TOKEN).
|
||||
# Имена - MagicDNS tailnet'а; `dell-dev` (дев-VM на делле) для контейнера
|
||||
# прописан через T3_DELL_DEV_ADDR.
|
||||
|
||||
[machines.mac]
|
||||
url = "http://mac:3773"
|
||||
token_env = "T3_MAC_TOKEN"
|
||||
projects = ["*"]
|
||||
model = "claudeAgent/claude-opus-5-5"
|
||||
options = { effort = "high", contextWindow = "1m" }
|
||||
|
||||
[machines.dell-dev]
|
||||
url = "http://dell-dev:3773"
|
||||
token_env = "T3_DELL_DEV_TOKEN"
|
||||
projects = ["*"]
|
||||
model = "claudeAgent/claude-opus-5-5"
|
||||
options = { effort = "high", contextWindow = "1m" }
|
||||
@@ -1,169 +0,0 @@
|
||||
import urllib.error
|
||||
from email.message import Message
|
||||
from datetime import UTC, datetime
|
||||
from zoneinfo import ZoneInfo
|
||||
|
||||
from beaver_agent.hands.calendars import (
|
||||
Calendars,
|
||||
Feed,
|
||||
calendars,
|
||||
events_in,
|
||||
feeds,
|
||||
is_routine,
|
||||
short,
|
||||
unfold,
|
||||
)
|
||||
|
||||
ZONE = ZoneInfo("Europe/Warsaw")
|
||||
NOW = datetime(2026, 9, 1, 12, 0, tzinfo=UTC) # 14:00 в Варшаве
|
||||
|
||||
MCPS = (
|
||||
"personal=https://calendar-mcp.com/api/mcp?email=b%40b.com"
|
||||
"&icsUrl=https%3A%2F%2Fcalendar.google.com%2Fical%2Fprivate-abc%2Fbasic.ics,"
|
||||
"student=https://calendar-mcp.com/api/mcp?icsUrl=https%3A%2F%2Fusos.pl%2Fics%3Fkey%3Dz,"
|
||||
"bare=https://calendar-mcp.com/mcp/AAAA"
|
||||
)
|
||||
|
||||
|
||||
def ics(*events: str) -> str:
|
||||
body = "".join(f"BEGIN:VEVENT\n{e.strip()}\nEND:VEVENT\n" for e in events)
|
||||
return f"BEGIN:VCALENDAR\nVERSION:2.0\nPRODID:-//test//EN\n{body}END:VCALENDAR\n"
|
||||
|
||||
|
||||
def starts(text: str, *, days: int = 7) -> list[str]:
|
||||
found = events_in(text, zone=ZONE, since=NOW.astimezone(ZONE), days=days)
|
||||
return [
|
||||
f"{e.start.astimezone(ZONE):%m-%d %H:%M} {e.title}"
|
||||
for e in sorted(found, key=lambda e: e.start)
|
||||
]
|
||||
|
||||
|
||||
def test_feeds_take_the_ical_url_out_of_the_same_mcp_urls():
|
||||
assert [f.name for f in feeds(MCPS)] == ["personal", "student"]
|
||||
assert feeds(MCPS)[0].url == (
|
||||
"https://calendar.google.com/ical/private-abc/basic.ics"
|
||||
)
|
||||
assert feeds(MCPS)[1].url == "https://usos.pl/ics?key=z"
|
||||
assert feeds("") == ()
|
||||
assert feeds("plain=https://example.com/plan.ics")[0].url.endswith("plan.ics")
|
||||
# MCP-рука остаётся у модели, даже если ical-фида в записи нет
|
||||
assert [m.name for m in calendars(MCPS)] == [
|
||||
"calendar-personal",
|
||||
"calendar-student",
|
||||
"calendar-bare",
|
||||
]
|
||||
|
||||
|
||||
def test_folded_lines_are_glued_back():
|
||||
assert unfold("SUMMARY:длин\r\n ное\r\nUID:x") == ["SUMMARY:длинное", "UID:x"]
|
||||
|
||||
|
||||
def test_window_sorts_by_start_and_keeps_only_the_next_days():
|
||||
text = ics(
|
||||
"SUMMARY:позже\nDTSTART:20260904T080000Z",
|
||||
"SUMMARY:раньше\nDTSTART:20260902T080000Z",
|
||||
"SUMMARY:за окном\nDTSTART:20260920T080000Z",
|
||||
"SUMMARY:уже прошло\nDTSTART:20260801T080000Z",
|
||||
)
|
||||
assert starts(text) == ["09-02 10:00 раньше", "09-04 10:00 позже"]
|
||||
|
||||
|
||||
def test_all_day_event_of_today_still_counts_as_upcoming():
|
||||
text = ics("SUMMARY:отпуск\nDTSTART;VALUE=DATE:20260901\nDTEND;VALUE=DATE:20260902")
|
||||
found = events_in(text, zone=ZONE, since=NOW.astimezone(ZONE), days=7)
|
||||
assert len(found) == 1
|
||||
assert found[0].all_day
|
||||
assert f"{found[0].start:%H:%M}" == "00:00"
|
||||
|
||||
|
||||
def test_place_takes_the_room_from_the_description_and_the_address_from_location():
|
||||
text = ics(
|
||||
"SUMMARY:Analiza matematyczna II - Egzamin\n"
|
||||
"DTSTART;VALUE=DATE-TIME:20260903T110000\n"
|
||||
"DESCRIPTION:Sala: 3\\nA23 - CW - Centrum Wykładowe\\n\n"
|
||||
"LOCATION:ul. Piotrowo 2\\, 61-138 Poznań\\, Polska"
|
||||
)
|
||||
found = events_in(text, zone=ZONE, since=NOW.astimezone(ZONE), days=7)
|
||||
assert found[0].place == "Sala: 3, ul. Piotrowo 2, 61-138 Poznań, Polska"
|
||||
# плавающее время читается в зоне агента, а не в UTC
|
||||
assert f"{found[0].start:%H:%M}" == "11:00"
|
||||
|
||||
|
||||
def test_cancelled_events_are_skipped():
|
||||
text = ics("SUMMARY:отменено\nDTSTART:20260902T080000Z\nSTATUS:CANCELLED")
|
||||
assert starts(text) == []
|
||||
|
||||
|
||||
def test_weekly_repeat_expands_and_exdate_with_moved_instance_are_subtracted():
|
||||
series = (
|
||||
"UID:w1\nSUMMARY:польский\nDTSTART;TZID=Europe/Warsaw:20260824T100000\n"
|
||||
"RRULE:FREQ=WEEKLY;BYDAY=MO,WE"
|
||||
)
|
||||
assert starts(ics(series)) == ["09-02 10:00 польский", "09-07 10:00 польский"]
|
||||
moved = ics(
|
||||
series + "\nEXDATE;TZID=Europe/Warsaw:20260902T100000",
|
||||
"UID:w1\nSUMMARY:польский (перенос)\n"
|
||||
"RECURRENCE-ID;TZID=Europe/Warsaw:20260907T100000\n"
|
||||
"DTSTART;TZID=Europe/Warsaw:20260907T173000",
|
||||
)
|
||||
assert starts(moved) == ["09-07 17:30 польский (перенос)"]
|
||||
|
||||
|
||||
def test_daily_repeat_stops_on_until_and_count():
|
||||
until = ics(
|
||||
"SUMMARY:завтрак\nDTSTART:20260801T060000Z\n"
|
||||
"RRULE:FREQ=DAILY;UNTIL=20260903T060000Z"
|
||||
)
|
||||
assert starts(until) == ["09-02 08:00 завтрак", "09-03 08:00 завтрак"]
|
||||
counted = ics("SUMMARY:курс\nDTSTART:20260902T060000Z\nRRULE:FREQ=DAILY;COUNT=3")
|
||||
assert len(starts(counted)) == 3
|
||||
yearly = ics(
|
||||
"SUMMARY:часы\nDTSTART:20200906T060000Z\nRRULE:FREQ=YEARLY;BYMONTH=9;BYDAY=1SU"
|
||||
)
|
||||
assert starts(yearly) == ["09-06 08:00 часы"]
|
||||
|
||||
|
||||
def test_a_working_week_is_routine_but_one_weekday_a_week_is_an_event():
|
||||
text = ics(
|
||||
"SUMMARY:пара\nDTSTART;TZID=Europe/Warsaw:20260831T100000\n"
|
||||
"RRULE:FREQ=WEEKLY;BYDAY=MO",
|
||||
"SUMMARY:зарядка\nDTSTART;TZID=Europe/Warsaw:20260831T070000\n"
|
||||
"RRULE:FREQ=WEEKLY;BYDAY=MO,TU,WE,TH,FR",
|
||||
)
|
||||
found = events_in(text, zone=ZONE, since=NOW.astimezone(ZONE), days=7)
|
||||
assert {e.title for e in found if e.routine} == {"зарядка"}
|
||||
assert {e.title for e in found if not e.routine} == {"пара"}
|
||||
assert len([e for e in found if e.routine]) == 5
|
||||
|
||||
|
||||
def test_routine_is_a_rule_that_fires_once_a_day_or_more_often():
|
||||
assert is_routine({"FREQ": "DAILY"})
|
||||
assert is_routine({"FREQ": "WEEKLY", "BYDAY": "MO,TU,WE,TH,FR,SA"})
|
||||
assert not is_routine({"FREQ": "WEEKLY", "BYDAY": "MO,WE,FR"})
|
||||
assert not is_routine({"FREQ": "WEEKLY"})
|
||||
assert not is_routine({"FREQ": "MONTHLY"})
|
||||
# через день - это уже не быт, такое видно поимённо
|
||||
assert not is_routine({"FREQ": "DAILY", "INTERVAL": "2"})
|
||||
|
||||
|
||||
def test_a_single_event_is_never_routine():
|
||||
text = ics("SUMMARY:Egzamin\nDTSTART:20260903T090000Z")
|
||||
assert not events_in(text, zone=ZONE, since=NOW.astimezone(ZONE), days=7)[0].routine
|
||||
|
||||
|
||||
def test_a_feed_that_fails_becomes_a_line_not_an_exception():
|
||||
class Broken(Calendars):
|
||||
def fetch(self, url: str) -> str:
|
||||
raise urllib.error.HTTPError(url, 403, "Forbidden", Message(), None)
|
||||
|
||||
broken = Broken((Feed("student", "https://usos.pl/ics"),), tz="Europe/Warsaw")
|
||||
found = broken.upcoming(NOW)
|
||||
assert found.read == 0
|
||||
assert found.events == ()
|
||||
assert found.errors == ("student: HTTP 403",)
|
||||
|
||||
|
||||
def test_short_reason_is_one_line_and_never_carries_the_url():
|
||||
assert short(TimeoutError()) == "таймаут"
|
||||
assert short(urllib.error.URLError("no route")).startswith("сеть:")
|
||||
assert short(ValueError("а\nб")) == "ValueError: а б"
|
||||
@@ -1,86 +0,0 @@
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from pathlib import Path
|
||||
|
||||
from beaver_agent.memory.curator import Watched, briefing, last_run, new_replies
|
||||
|
||||
|
||||
def test_last_run_reads_first_line_or_default(tmp_path: Path) -> None:
|
||||
default = datetime(2026, 9, 1, tzinfo=UTC)
|
||||
assert last_run(tmp_path / "нет.md", default=default) == default
|
||||
j = tmp_path / "куратор.md"
|
||||
j.write_text(
|
||||
"последний прогон: 2026-09-01T18:00:00+02:00\n\n# журнал\n", encoding="utf-8"
|
||||
)
|
||||
assert last_run(j, default=default) == datetime(2026, 9, 1, 16, 0, tzinfo=UTC)
|
||||
j.write_text("# журнал без строки\n", encoding="utf-8")
|
||||
assert last_run(j, default=default) == default
|
||||
|
||||
|
||||
def test_briefing_lists_new_replies_and_changed_files_or_nothing(
|
||||
tmp_path: Path,
|
||||
) -> None:
|
||||
vault = tmp_path
|
||||
beaver = vault / "мета" / "бобер"
|
||||
replies = beaver / "реплики"
|
||||
notes = beaver / "наблюдения"
|
||||
replies.mkdir(parents=True)
|
||||
notes.mkdir()
|
||||
(replies / "2026-08-31.md").write_text(
|
||||
"# реплики\n\n- 2026-08-31 23:50 · мастер · вчерашнее\n", encoding="utf-8"
|
||||
)
|
||||
(replies / "2026-09-01.md").write_text(
|
||||
"# реплики\n\n- 2026-09-01 12:00 · мастер · старое\n- 2026-09-01 19:30 · мастер · новое сообщение\n",
|
||||
encoding="utf-8",
|
||||
)
|
||||
journal = beaver / "куратор.md"
|
||||
journal.write_text(
|
||||
"последний прогон: 2026-09-01T18:00:00+02:00\n", encoding="utf-8"
|
||||
)
|
||||
old = notes / "Глафира - наблюдения.md"
|
||||
old.write_text("# Глафира\n", encoding="utf-8")
|
||||
import os
|
||||
|
||||
stale = (datetime(2026, 9, 1, 10, tzinfo=UTC)).timestamp()
|
||||
os.utime(old, (stale, stale))
|
||||
fresh = notes / "Зина - наблюдения.md"
|
||||
fresh.write_text(
|
||||
"# Зина\n## лента\n- 2026-09-01 · факт · [[2026-09-01]]\n", encoding="utf-8"
|
||||
)
|
||||
now = datetime(2026, 9, 1, 20, 0, tzinfo=UTC)
|
||||
recent = (now - timedelta(minutes=30)).timestamp()
|
||||
os.utime(fresh, (recent, recent))
|
||||
text = briefing(
|
||||
vault=vault,
|
||||
journal=journal,
|
||||
runs=beaver / "куратор",
|
||||
replies_dir=replies,
|
||||
watched=[Watched("наблюдения", notes)],
|
||||
tz="Europe/Warsaw",
|
||||
now=now,
|
||||
)
|
||||
assert text is not None
|
||||
assert "прошлый - 2026-09-01 18:00" in text
|
||||
assert (
|
||||
"Новые реплики Бобра (1):\n- 2026-09-01 19:30 · мастер · новое сообщение"
|
||||
in text
|
||||
)
|
||||
assert "наблюдения: `мета/бобер/наблюдения/Зина - наблюдения.md`" in text
|
||||
assert "Глафира" not in text
|
||||
assert "последний прогон: 2026-09-01T22:00:00+02:00" in text
|
||||
assert "запись о прогоне - в `мета/бобер/куратор/2026-09-01.md`" in text
|
||||
|
||||
journal.write_text(f"последний прогон: {now.isoformat()}\n", encoding="utf-8")
|
||||
assert new_replies(replies, now, "Europe/Warsaw") == []
|
||||
later = now + timedelta(hours=1)
|
||||
assert (
|
||||
briefing(
|
||||
vault=vault,
|
||||
journal=journal,
|
||||
runs=beaver / "куратор",
|
||||
replies_dir=replies,
|
||||
watched=[Watched("наблюдения", notes)],
|
||||
tz="Europe/Warsaw",
|
||||
now=later,
|
||||
)
|
||||
is None
|
||||
)
|
||||
@@ -1,72 +0,0 @@
|
||||
import os
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from zoneinfo import ZoneInfo
|
||||
|
||||
import pytest
|
||||
|
||||
from beaver_agent.memory import handouts
|
||||
from beaver_agent.memory.handouts import deploy_mark
|
||||
|
||||
ZONE = ZoneInfo("Europe/Warsaw")
|
||||
NOW = "2026-09-17 06:30"
|
||||
|
||||
|
||||
def _at(text: str) -> float:
|
||||
return datetime.fromisoformat(text).replace(tzinfo=ZONE).timestamp()
|
||||
|
||||
|
||||
def _touch(path: Path, when: str) -> Path:
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_text("", encoding="utf-8")
|
||||
os.utime(path, (_at(when), _at(when)))
|
||||
return path
|
||||
|
||||
|
||||
def _bundle(tmp_path: Path, started: str, code: str) -> tuple[Path, Path]:
|
||||
proc = _touch(tmp_path / "proc" / "1", started)
|
||||
package = tmp_path / "beaver_agent"
|
||||
_touch(package / "memory" / "handouts.py", code)
|
||||
_touch(package / "vault.py", "2026-09-10 12:00")
|
||||
# мусор компилятора не должен выглядеть свежим кодом
|
||||
_touch(package / "memory" / "__pycache__" / "handouts.py", "2026-09-17 06:00")
|
||||
return proc, package
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def _now(monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
monkeypatch.setattr(handouts.time, "time", lambda: _at(NOW))
|
||||
|
||||
|
||||
def test_code_older_than_start(tmp_path: Path) -> None:
|
||||
proc, package = _bundle(tmp_path, "2026-09-16 03:11", "2026-09-16 03:03")
|
||||
assert deploy_mark(proc, package) == (
|
||||
"Выкат: процесс поднят 2026-09-16 03:11 (27 ч назад), свежесть кода "
|
||||
"2026-09-16 03:03 - код старше старта, значит крутится то, что выкатывали."
|
||||
)
|
||||
|
||||
|
||||
def test_code_newer_than_start(tmp_path: Path) -> None:
|
||||
proc, package = _bundle(tmp_path, "2026-09-16 03:11", "2026-09-17 06:20")
|
||||
assert deploy_mark(proc, package) == (
|
||||
"Выкат: процесс поднят 2026-09-16 03:11 (27 ч назад), свежесть кода "
|
||||
"2026-09-17 06:20 - код НОВЕЕ старта: правка на диске есть, "
|
||||
"рестарта после неё не было."
|
||||
)
|
||||
|
||||
|
||||
def test_same_minute(tmp_path: Path) -> None:
|
||||
proc, package = _bundle(tmp_path, "2026-09-17 06:00", "2026-09-17 06:00:30")
|
||||
assert deploy_mark(proc, package) == (
|
||||
"Выкат: процесс поднят 2026-09-17 06:00 (30 мин назад), свежесть кода "
|
||||
"2026-09-17 06:00 - выкат и правка в одну минуту."
|
||||
)
|
||||
|
||||
|
||||
def test_no_source(tmp_path: Path) -> None:
|
||||
proc, package = _bundle(tmp_path, "2026-09-16 03:11", "2026-09-16 03:03")
|
||||
assert deploy_mark(tmp_path / "нет", package) is None
|
||||
assert deploy_mark(proc, tmp_path / "пусто") is None
|
||||
only_cache = tmp_path / "кеш"
|
||||
_touch(only_cache / "__pycache__" / "handouts.py", "2026-09-17 06:00")
|
||||
assert deploy_mark(proc, only_cache) is None
|
||||
@@ -1,575 +0,0 @@
|
||||
import json
|
||||
import logging
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from types import SimpleNamespace
|
||||
from typing import Any, cast
|
||||
from urllib.parse import parse_qsl, urlsplit
|
||||
from zoneinfo import ZoneInfo
|
||||
|
||||
from beaver_agent.hands.heartbeat import (
|
||||
PEER,
|
||||
Watch,
|
||||
alarm_text,
|
||||
beat_line,
|
||||
drill,
|
||||
every_from_cron,
|
||||
look,
|
||||
parse_beat,
|
||||
parse_span,
|
||||
span,
|
||||
)
|
||||
from beaver_agent.hands.vibegram import PAGE, Event, Vibegram, Window
|
||||
|
||||
WARSAW = ZoneInfo("Europe/Warsaw")
|
||||
NOW = datetime(2026, 9, 22, 15, 42, tzinfo=UTC)
|
||||
|
||||
|
||||
def hb(at, *, every="24h", nick=PEER, eid=100):
|
||||
return Event(
|
||||
id=eid,
|
||||
nick=nick,
|
||||
kind="message",
|
||||
text=(
|
||||
f"{nick}: hb {nick} at={at.strftime('%Y-%m-%dT%H:%M:%SZ')} "
|
||||
f"boot=2026-09-01T03:00:00Z every={every} src=cron+uptime-s"
|
||||
),
|
||||
at="09-22 07:00",
|
||||
)
|
||||
|
||||
|
||||
def state(tmp_path, **kw):
|
||||
return Watch(path=tmp_path / "сторож.json", **kw)
|
||||
|
||||
|
||||
def test_parse_beat_reads_fields_and_unknown_every():
|
||||
beat = parse_beat(
|
||||
"claude-kai: hb claude-kai at=2026-09-22T05:00:00Z "
|
||||
"boot=2026-09-01T03:00:00Z every=24h src=cron+uptime-s"
|
||||
)
|
||||
assert beat is not None
|
||||
assert beat.nick == "claude-kai"
|
||||
assert beat.at == datetime(2026, 9, 22, 5, 0, tzinfo=UTC)
|
||||
assert beat.boot == datetime(2026, 9, 1, 3, 0, tzinfo=UTC)
|
||||
assert beat.every == timedelta(hours=24)
|
||||
|
||||
unknown = parse_beat(
|
||||
"claude-kai: hb claude-kai at=2026-09-22T05:00:00Z "
|
||||
"boot=? every=unknown src=none"
|
||||
)
|
||||
assert unknown is not None
|
||||
assert unknown.every is None and unknown.every_raw == "unknown"
|
||||
assert unknown.boot is None
|
||||
|
||||
assert parse_beat("claude-kai: просто сообщение") is None
|
||||
assert parse_beat("claude-kai: ack beaver last=x", "ack") is not None
|
||||
|
||||
|
||||
def test_span_round_trip():
|
||||
assert span(timedelta(hours=36)) == "36h"
|
||||
assert span(timedelta(minutes=90)) == "90m"
|
||||
assert span(None) == "unknown"
|
||||
assert parse_span("36h") == timedelta(hours=36)
|
||||
assert parse_span("unknown") is None
|
||||
assert parse_span("") is None
|
||||
|
||||
|
||||
def test_every_from_cron_only_when_schedule_is_every_n_hours():
|
||||
assert every_from_cron("12 17 * * *", WARSAW, now=NOW) == timedelta(hours=24)
|
||||
assert every_from_cron("0 */6 * * *", WARSAW, now=NOW) == timedelta(hours=6)
|
||||
# Перевод стрелок не делает суточный крон 23-часовым: считаем по стенным часам
|
||||
march = datetime(2026, 3, 28, 12, tzinfo=UTC)
|
||||
assert every_from_cron("12 17 * * *", WARSAW, now=march) == timedelta(hours=24)
|
||||
# Не сводится к «раз в N часов» - и не сводим
|
||||
assert every_from_cron("0 2,8,12,16,20 * * *", WARSAW, now=NOW) is None
|
||||
assert every_from_cron("*/10 * * * *", WARSAW, now=NOW) is None
|
||||
# Недельный крон тоже сводится к N часам - это честные 168h, а не unknown
|
||||
assert every_from_cron("30 4 * * 0", WARSAW, now=NOW) == timedelta(hours=168)
|
||||
assert every_from_cron(None, WARSAW, now=NOW) is None
|
||||
assert every_from_cron("не крон", WARSAW, now=NOW) is None
|
||||
|
||||
|
||||
def test_beat_line_says_unknown_instead_of_guessing():
|
||||
line = beat_line(
|
||||
nick="beaver",
|
||||
at=datetime(2026, 9, 22, 15, 12, tzinfo=UTC),
|
||||
boot=datetime(2026, 9, 20, 1, 2, 3, tzinfo=UTC),
|
||||
every=timedelta(hours=24),
|
||||
)
|
||||
assert line == (
|
||||
"hb beaver at=2026-09-22T15:12:00Z boot=2026-09-20T01:02:03Z every=24h src=cron"
|
||||
)
|
||||
blind = beat_line(nick="beaver", at=NOW, boot=NOW, every=None)
|
||||
assert "every=unknown src=none" in blind
|
||||
|
||||
|
||||
def test_fresh_beat_arms_and_stays_quiet(tmp_path):
|
||||
w = state(tmp_path)
|
||||
report = look(
|
||||
w, [hb(NOW - timedelta(hours=10))], now=NOW, res=timedelta(hours=24), full=True
|
||||
)
|
||||
assert report.armed and report.alarm is None and not report.stale
|
||||
assert report.threshold == timedelta(hours=36)
|
||||
assert "armed=yes" in report.ack and "win=25" in report.ack
|
||||
assert "res=24h" in report.ack and "thr=36h" in report.ack
|
||||
assert w.seen == NOW and w.top == 100
|
||||
|
||||
|
||||
def test_same_beat_seen_twice_does_not_move_seen(tmp_path):
|
||||
w = state(tmp_path)
|
||||
old = hb(NOW - timedelta(hours=1), eid=200)
|
||||
first = look(w, [old], now=NOW, res=None, full=True)
|
||||
assert first.armed and first.alarm is None
|
||||
assert w.seen == NOW and w.beat_id == 200
|
||||
|
||||
# Тот же самый hb в окне следующего прогона - это не новое показание
|
||||
again = look(w, [old], now=NOW + timedelta(hours=6), res=None, full=True)
|
||||
assert w.seen == NOW and again.alarm is None
|
||||
assert "отметка та же" in again.note
|
||||
|
||||
# И через порог 36h та же отметка уже не выглядит живой цепью
|
||||
late = NOW + timedelta(hours=37)
|
||||
loud = look(w, [old], now=late, res=None, full=True)
|
||||
assert loud.alarm == "silence" and w.seen == NOW
|
||||
assert loud.age is not None and loud.age > timedelta(hours=36)
|
||||
|
||||
# Пришла новая отметка - новый id, и seen снова двигается
|
||||
fresh = look(w, [old, hb(late, eid=201)], now=late, res=None, full=True)
|
||||
assert fresh.alarm is None and w.seen == late and w.beat_id == 201
|
||||
|
||||
|
||||
def test_state_without_beat_id_trusts_its_own_seen(tmp_path):
|
||||
path = tmp_path / "сторож.json"
|
||||
path.write_text(
|
||||
json.dumps(
|
||||
{
|
||||
"version": 1,
|
||||
"at": "2026-09-21T05:00:01Z",
|
||||
"seen": "2026-09-22T05:42:01Z",
|
||||
"every": 86400,
|
||||
"every_unknown": False,
|
||||
"top": 300,
|
||||
"alerted": None,
|
||||
"unarmed_since": None,
|
||||
"unarmed_told": False,
|
||||
}
|
||||
),
|
||||
encoding="utf-8",
|
||||
)
|
||||
w = Watch.load(path)
|
||||
was = datetime(2026, 9, 22, 5, 42, 1, tzinfo=UTC)
|
||||
assert w.beat_id == 0 and w.seen == was
|
||||
|
||||
old = hb(datetime(2026, 9, 21, 5, 0, 1, tzinfo=UTC), eid=305)
|
||||
assert look(w, [old], now=NOW, res=None, full=True).alarm is None
|
||||
assert w.seen == was and w.beat_id == 305
|
||||
# Старое состояние не пере-вооружилось на старой отметке: порог придёт в срок
|
||||
over = datetime(2026, 9, 23, 20, 0, tzinfo=UTC)
|
||||
assert look(w, [old], now=over, res=None, full=True).alarm == "silence"
|
||||
|
||||
|
||||
def test_threshold_is_every_times_one_and_a_half(tmp_path):
|
||||
# 30 часов при every=24h - ещё не тревога: одна потерянная строка не в счёт
|
||||
quiet = state(tmp_path, seen=NOW - timedelta(hours=30), every=timedelta(hours=24))
|
||||
assert look(quiet, [], now=NOW, res=timedelta(hours=24), full=True).alarm is None
|
||||
# 37 часов - уже за порогом 36
|
||||
loud = state(tmp_path, seen=NOW - timedelta(hours=37), every=timedelta(hours=24))
|
||||
report = look(loud, [], now=NOW, res=timedelta(hours=24), full=True)
|
||||
assert report.alarm == "silence"
|
||||
# Порог берётся из строки соседа, а не из нашей константы
|
||||
slow = state(tmp_path, seen=NOW - timedelta(hours=37), every=timedelta(hours=48))
|
||||
assert look(slow, [], now=NOW, res=timedelta(hours=24), full=True).alarm is None
|
||||
|
||||
|
||||
def test_last_beat_wins_over_gaps(tmp_path):
|
||||
w = state(tmp_path, seen=NOW - timedelta(hours=40), every=timedelta(hours=24))
|
||||
report = look(
|
||||
w, [hb(NOW - timedelta(hours=1), eid=120)], now=NOW, res=None, full=True
|
||||
)
|
||||
assert report.alarm is None
|
||||
assert report.age is not None and report.age < timedelta(hours=2)
|
||||
assert "res=unknown" in report.ack
|
||||
|
||||
|
||||
def test_unknown_every_falls_back_to_last_known_and_says_so(tmp_path):
|
||||
w = state(tmp_path, every=timedelta(hours=24))
|
||||
report = look(w, [hb(NOW, every="unknown", eid=130)], now=NOW, res=None, full=True)
|
||||
assert report.threshold == timedelta(hours=36)
|
||||
assert "thr=36h-fallback" in report.ack
|
||||
assert w.every == timedelta(hours=24)
|
||||
|
||||
|
||||
def test_no_period_ever_means_no_measurement_and_no_alarm(tmp_path):
|
||||
w = state(tmp_path, seen=NOW - timedelta(days=9))
|
||||
report = look(w, [], now=NOW, res=timedelta(hours=24), full=True)
|
||||
assert report.alarm is None and report.threshold is None
|
||||
assert "thr=unknown" in report.ack
|
||||
assert "мерить нечем" in report.note
|
||||
|
||||
|
||||
def test_never_seen_is_armed_no_not_alarm(tmp_path):
|
||||
w = state(tmp_path)
|
||||
report = look(w, [], now=NOW, res=timedelta(hours=24), full=True)
|
||||
assert not report.armed and report.alarm is None
|
||||
assert "armed=no" in report.ack and "last=never seen=never" in report.ack
|
||||
assert w.unarmed_since == NOW
|
||||
|
||||
|
||||
def test_seven_days_unarmed_tells_the_human_once(tmp_path):
|
||||
w = state(tmp_path, unarmed_since=NOW - timedelta(days=7))
|
||||
assert look(w, [], now=NOW, res=timedelta(hours=24), full=True).alarm == "unarmed"
|
||||
w.unarmed_told = True
|
||||
assert look(w, [], now=NOW, res=timedelta(hours=24), full=True).alarm is None
|
||||
# Пришла первая отметка - кольцо вооружилось, счётчик забыт
|
||||
look(w, [hb(NOW, eid=140)], now=NOW, res=timedelta(hours=24), full=True)
|
||||
assert w.unarmed_since is None
|
||||
|
||||
|
||||
def test_stale_window_forbids_alarm(tmp_path):
|
||||
w = state(
|
||||
tmp_path, seen=NOW - timedelta(hours=40), every=timedelta(hours=24), top=500
|
||||
)
|
||||
report = look(
|
||||
w, [hb(NOW - timedelta(hours=40), eid=7)], now=NOW, res=None, full=True
|
||||
)
|
||||
assert report.stale and report.alarm is None
|
||||
assert "win=stale" in report.ack
|
||||
assert w.top == 500 # съехавшее окно не двигает отметку максимума
|
||||
# Окно снова вперёд - тревога берётся
|
||||
fresh = look(
|
||||
w, [hb(NOW - timedelta(hours=40), eid=501)], now=NOW, res=None, full=True
|
||||
)
|
||||
assert not fresh.stale
|
||||
|
||||
|
||||
def test_alarm_not_repeated_within_a_day(tmp_path):
|
||||
w = state(
|
||||
tmp_path,
|
||||
seen=NOW - timedelta(hours=40),
|
||||
every=timedelta(hours=24),
|
||||
alerted=NOW - timedelta(hours=5),
|
||||
)
|
||||
assert look(w, [], now=NOW, res=None, full=True).alarm is None
|
||||
w.alerted = NOW - timedelta(hours=25)
|
||||
assert look(w, [], now=NOW, res=None, full=True).alarm == "silence"
|
||||
|
||||
|
||||
def test_ack_says_what_the_instrument_decided(tmp_path):
|
||||
# Цепь жива - решать нечего
|
||||
alive = state(tmp_path)
|
||||
assert "alert=none" in look(alive, [hb(NOW)], now=NOW, res=None, full=True).ack
|
||||
# Порог пройден, тревога взята в этом прогоне
|
||||
loud = state(tmp_path, seen=NOW - timedelta(hours=40), every=timedelta(hours=24))
|
||||
fired = look(loud, [], now=NOW, res=None, full=True)
|
||||
assert fired.alarm == "silence" and "alert=fired" in fired.ack
|
||||
# Порог пройден, но тревога уходила меньше суток назад - повтор подавлен
|
||||
loud.alerted = NOW - timedelta(hours=5)
|
||||
held = look(loud, [], now=NOW, res=None, full=True)
|
||||
assert held.alarm is None and "alert=held" in held.ack
|
||||
# Кольцо так и не вооружилось дольше недели - это тоже выстрел
|
||||
late = state(tmp_path, unarmed_since=NOW - timedelta(days=8))
|
||||
assert "alert=fired" in look(late, [], now=NOW, res=None, full=True).ack
|
||||
# Показания нет (окно не дочитано) - не `held`, а `none`: подавлять нечего
|
||||
unread = state(tmp_path, seen=NOW - timedelta(hours=40), every=timedelta(hours=24))
|
||||
assert "alert=none" in look(unread, [], now=NOW, res=None, full=False).ack
|
||||
|
||||
|
||||
def test_drill_flag_is_a_list_of_local_dates(tmp_path):
|
||||
flag = tmp_path / "сторож-учения.txt"
|
||||
assert not drill(flag, now=NOW, tz=WARSAW) # файла нет - отметка уходит
|
||||
flag.write_text("\n \n", encoding="utf-8")
|
||||
assert not drill(flag, now=NOW, tz=WARSAW) # пустой - тоже
|
||||
flag.write_text("2026-09-28\n2026-09-29\n", encoding="utf-8")
|
||||
assert drill(flag, now=datetime(2026, 9, 28, 15, 12, tzinfo=UTC), tz=WARSAW)
|
||||
assert not drill(flag, now=datetime(2026, 9, 27, 15, 12, tzinfo=UTC), tz=WARSAW)
|
||||
# Дата локальная в зоне планировщика: 22:30 UTC - это уже 29-е в Варшаве
|
||||
assert drill(flag, now=datetime(2026, 9, 28, 22, 30, tzinfo=UTC), tz=WARSAW)
|
||||
assert not drill(flag, now=datetime(2026, 9, 29, 22, 30, tzinfo=UTC), tz=WARSAW)
|
||||
|
||||
|
||||
def test_alarm_text_names_three_causes_and_suspects_the_channel(tmp_path):
|
||||
w = state(tmp_path, seen=NOW - timedelta(hours=40), every=timedelta(hours=24))
|
||||
report = look(w, [], now=NOW, res=timedelta(hours=24), full=True)
|
||||
silent = alarm_text(report, mine_sent=True)
|
||||
assert "машина соседа" in silent and "крон" in silent and "канал" in silent
|
||||
assert "канал подозревать надо раньше" in silent
|
||||
# Сосед хоть чем-то отметился - канал скорее жив
|
||||
heard = look(
|
||||
state(tmp_path, seen=NOW - timedelta(hours=40), every=timedelta(hours=24)),
|
||||
[
|
||||
Event(
|
||||
id=9,
|
||||
nick=PEER,
|
||||
kind="message",
|
||||
text=f"{PEER}: ack beaver last=x",
|
||||
at="09-22 07:00",
|
||||
)
|
||||
],
|
||||
now=NOW,
|
||||
res=None,
|
||||
full=True,
|
||||
)
|
||||
assert heard.heard
|
||||
assert "канал скорее жив" in alarm_text(heard, mine_sent=True)
|
||||
|
||||
|
||||
def test_state_survives_a_round_trip(tmp_path):
|
||||
w = state(
|
||||
tmp_path,
|
||||
at=NOW,
|
||||
seen=NOW,
|
||||
every=timedelta(hours=24),
|
||||
every_unknown=True,
|
||||
beat_id=329,
|
||||
top=42,
|
||||
alerted=NOW,
|
||||
unarmed_since=None,
|
||||
unarmed_told=True,
|
||||
)
|
||||
w.save()
|
||||
back = Watch.load(w.path)
|
||||
assert back.at == NOW and back.seen == NOW and back.top == 42
|
||||
assert back.beat_id == 329
|
||||
assert back.every == timedelta(hours=24) and back.every_unknown
|
||||
assert back.alerted == NOW and back.unarmed_told
|
||||
assert Watch.load(tmp_path / "нет.json").seen is None
|
||||
|
||||
|
||||
class FakeRoom:
|
||||
def __init__(self, events, *, nick="beaver", send_fails=False, full=True):
|
||||
self.events = events
|
||||
self.nick = nick
|
||||
self.send_fails = send_fails
|
||||
self.full = full
|
||||
self.said = []
|
||||
self.limit = None
|
||||
|
||||
async def window(self, limit=25):
|
||||
self.limit = limit
|
||||
return Window(events=self.events, full=self.full)
|
||||
|
||||
async def say(self, text):
|
||||
if self.send_fails:
|
||||
msg = "хаб молчит"
|
||||
raise RuntimeError(msg)
|
||||
self.said.append(text)
|
||||
|
||||
|
||||
class FakeRun:
|
||||
def __init__(self, cron="42 */6 * * *"):
|
||||
self.job = SimpleNamespace(cron=cron, name="сторож")
|
||||
self.scheduler = SimpleNamespace(tz=WARSAW)
|
||||
self.spawned = []
|
||||
|
||||
async def spawn_job(self, *, agent, text, title=None):
|
||||
self.spawned.append((agent, title, text))
|
||||
return None
|
||||
|
||||
|
||||
async def test_watch_job_prints_ack_and_spawns_alarm(tmp_path, monkeypatch):
|
||||
from beaver_agent.jobs import heartbeat as job
|
||||
|
||||
monkeypatch.setattr(job, "STATE_FILE", tmp_path / "сторож.json")
|
||||
Watch(
|
||||
path=tmp_path / "сторож.json",
|
||||
seen=datetime.now(UTC) - timedelta(hours=40),
|
||||
every=timedelta(hours=24),
|
||||
).save()
|
||||
room = FakeRoom([])
|
||||
monkeypatch.setattr(job, "VIBEGRAM_HB", room)
|
||||
run = FakeRun()
|
||||
|
||||
await job.watch(cast("Any", run))
|
||||
|
||||
assert room.limit == 25 # окно запрошено явным размером
|
||||
assert room.said and room.said[0].startswith(f"ack {PEER} ")
|
||||
assert "res=6h" in room.said[0]
|
||||
assert len(run.spawned) == 1
|
||||
agent, title, text = run.spawned[0]
|
||||
assert agent == "beaver-triage" and title == "сторож"
|
||||
assert "канал подозревать надо раньше" in text
|
||||
# Тревога записана в состояние - следующий прогон в те же сутки молчит
|
||||
assert Watch.load(tmp_path / "сторож.json").alerted is not None
|
||||
await job.watch(cast("Any", run))
|
||||
assert len(run.spawned) == 1
|
||||
|
||||
|
||||
async def test_beat_job_sends_period_from_its_own_cron(monkeypatch):
|
||||
from beaver_agent.jobs import heartbeat as job
|
||||
|
||||
room = FakeRoom([], nick="beaver")
|
||||
monkeypatch.setattr(job, "VIBEGRAM_HB", room)
|
||||
await job.beat(cast("Any", FakeRun(cron="12 17 * * *")))
|
||||
assert room.said[0].startswith("hb beaver at=")
|
||||
assert "every=24h src=cron" in room.said[0]
|
||||
|
||||
odd = FakeRoom([], nick="beaver")
|
||||
monkeypatch.setattr(job, "VIBEGRAM_HB", odd)
|
||||
await job.beat(cast("Any", FakeRun(cron="0 2,8,12,16,20 * * *")))
|
||||
assert "every=unknown src=none" in odd.said[0]
|
||||
|
||||
|
||||
async def test_beat_job_keeps_silent_on_a_drill_day(tmp_path, monkeypatch, caplog):
|
||||
from beaver_agent.jobs import heartbeat as job
|
||||
|
||||
flag = tmp_path / "сторож-учения.txt"
|
||||
monkeypatch.setattr(job, "DRILL_FILE", flag)
|
||||
room = FakeRoom([], nick="beaver")
|
||||
monkeypatch.setattr(job, "VIBEGRAM_HB", room)
|
||||
today = datetime.now(WARSAW).strftime("%Y-%m-%d")
|
||||
|
||||
flag.write_text(f"2026-01-01\n{today}\n", encoding="utf-8")
|
||||
with caplog.at_level(logging.INFO):
|
||||
await job.beat(cast("Any", FakeRun(cron="12 17 * * *")))
|
||||
assert not room.said # молчание в комнате и есть учения
|
||||
assert "пропущена по флагу" in caplog.text
|
||||
|
||||
# Не наш день - отметка уходит как обычно
|
||||
flag.write_text("2026-01-01\n", encoding="utf-8")
|
||||
await job.beat(cast("Any", FakeRun(cron="12 17 * * *")))
|
||||
assert len(room.said) == 1 and room.said[0].startswith("hb beaver at=")
|
||||
|
||||
# Файла нет - тоже обычный прогон
|
||||
flag.unlink()
|
||||
await job.beat(cast("Any", FakeRun(cron="12 17 * * *")))
|
||||
assert len(room.said) == 2
|
||||
|
||||
|
||||
async def test_watch_job_keeps_quiet_when_the_room_is_unreadable(tmp_path, monkeypatch):
|
||||
from beaver_agent.jobs import heartbeat as job
|
||||
|
||||
class Dead(FakeRoom):
|
||||
async def window(self, limit=25):
|
||||
msg = "хаб не отвечает"
|
||||
raise RuntimeError(msg)
|
||||
|
||||
monkeypatch.setattr(job, "STATE_FILE", tmp_path / "сторож.json")
|
||||
monkeypatch.setattr(job, "VIBEGRAM_HB", Dead([]))
|
||||
run = FakeRun()
|
||||
await job.watch(cast("Any", run))
|
||||
assert not run.spawned
|
||||
assert not (tmp_path / "сторож.json").exists()
|
||||
|
||||
|
||||
class FakeHub:
|
||||
"""Хаб как он есть: id сквозные по ВСЕМ комнатам, `/api/state` - наша.
|
||||
|
||||
Хвост комнаты лежит за `/api/state?view=…&after=<id>` и отдаётся
|
||||
страницами вперёд; `/api/pending` - курсор, и сторожу в него ходить
|
||||
нечего: то же событие второй раз оттуда не придёт.
|
||||
"""
|
||||
|
||||
def __init__(self, events, *, page=PAGE):
|
||||
self.events = events
|
||||
self.page = page
|
||||
self.said = []
|
||||
self.afters = []
|
||||
|
||||
async def call(self, method, path, body):
|
||||
if method == "POST" and path == "/api/messages":
|
||||
self.said.append(body["body"])
|
||||
return {"ok": True}
|
||||
if path == "/api/room":
|
||||
return {"room": {"id": "dbb", "name": "kai-rem-watch", "viewToken": "v-1"}}
|
||||
if path.startswith("/api/state"):
|
||||
query = dict(parse_qsl(urlsplit(path).query))
|
||||
assert query["view"] == "v-1"
|
||||
after = int(query.get("after", 0))
|
||||
self.afters.append(after)
|
||||
rest = [e for e in self.events if e["id"] > after]
|
||||
return {"room": {}, "agents": [], "events": rest[: self.page]}
|
||||
msg = f"сторож не должен ходить в {path}"
|
||||
raise AssertionError(msg)
|
||||
|
||||
|
||||
def raw(eid, nick, kind, body=None, at="2026-09-23T05:00:02.000Z"):
|
||||
return {
|
||||
"id": eid,
|
||||
"roomId": "dbb",
|
||||
"nick": nick,
|
||||
"kind": kind,
|
||||
"payload": {} if body is None else {"body": body},
|
||||
"createdAt": at,
|
||||
}
|
||||
|
||||
|
||||
def room(monkeypatch, events, *, page=PAGE):
|
||||
hub = FakeHub(events, page=page)
|
||||
|
||||
async def call(self, method, path, body):
|
||||
return await hub.call(method, path, body)
|
||||
|
||||
monkeypatch.setattr(Vibegram, "_call", call)
|
||||
return hub, Vibegram(hub="http://hub", token="t", nick="beaver-rem")
|
||||
|
||||
|
||||
KAI_HB = (
|
||||
f"hb {PEER} at=2026-09-23T05:00:01Z boot=2026-09-14T08:21:55Z "
|
||||
"every=24h src=cron+uptime-s"
|
||||
)
|
||||
|
||||
|
||||
async def test_window_is_the_rooms_last_messages_not_the_hubs_last_ids(
|
||||
tmp_path, monkeypatch, caplog
|
||||
):
|
||||
from beaver_agent.jobs import heartbeat as job
|
||||
|
||||
# В комнате три события, а по хабу за то же время прошло три десятка:
|
||||
# номера сквозные, и между 296 и 336 лежат чужие комнаты. Отметка соседа
|
||||
# (#329) обязана быть в окне - в комнате она первая с конца.
|
||||
hub, client = room(
|
||||
monkeypatch,
|
||||
[
|
||||
raw(296, PEER, "agent_join"),
|
||||
raw(329, PEER, "message", KAI_HB),
|
||||
raw(331, "beaver-rem", "agent_leave"),
|
||||
raw(332, "beaver-rem", "message", "hb beaver-rem at=2026-09-23T15:12:01Z"),
|
||||
raw(336, PEER, "message", "ack beaver-rem last=2026-09-23T15:12:01Z"),
|
||||
],
|
||||
)
|
||||
monkeypatch.setattr(job, "STATE_FILE", tmp_path / "сторож.json")
|
||||
monkeypatch.setattr(job, "VIBEGRAM_HB", client)
|
||||
|
||||
window = await client.window(25)
|
||||
assert window.full
|
||||
assert [e.id for e in window.events] == [329, 332, 336] # join/leave не в счёт
|
||||
assert parse_beat(window.events[0].text) is not None
|
||||
|
||||
# Два прогона подряд: отметка соседа в окне оба раза, а не только в первом
|
||||
with caplog.at_level(logging.INFO, logger="beaver_agent.jobs.heartbeat"):
|
||||
await job.watch(cast("Any", FakeRun()))
|
||||
await job.watch(cast("Any", FakeRun()))
|
||||
beats = [m for m in caplog.messages if "отметок соседа в окне: 1" in m]
|
||||
assert len(beats) == 2
|
||||
assert all("история дочитана" in m for m in beats)
|
||||
assert all("last=2026-09-23T05:00:01Z" in a and "armed=yes" in a for a in hub.said)
|
||||
assert all("win=25 " in a for a in hub.said)
|
||||
assert hub.afters == [0, 0, 0] # одна страница на прогон, читать дальше нечего
|
||||
|
||||
|
||||
async def test_a_hundred_noise_lines_do_not_push_the_control_beat_out(
|
||||
tmp_path, monkeypatch
|
||||
):
|
||||
from beaver_agent.jobs import heartbeat as job
|
||||
|
||||
# Учения соседа: сотня шумовых строк в комнату и контрольная hb после них.
|
||||
noise = [raw(400 + i, PEER, "message", f"шум {i}") for i in range(100)]
|
||||
hub, client = room(monkeypatch, [*noise, raw(600, PEER, "message", KAI_HB)])
|
||||
monkeypatch.setattr(job, "STATE_FILE", tmp_path / "сторож.json")
|
||||
monkeypatch.setattr(job, "VIBEGRAM_HB", client)
|
||||
|
||||
await job.watch(cast("Any", FakeRun()))
|
||||
|
||||
assert "last=2026-09-23T05:00:01Z" in hub.said[0] and "armed=yes" in hub.said[0]
|
||||
assert Watch.load(tmp_path / "сторож.json").top == 600
|
||||
|
||||
|
||||
def test_unread_window_is_named_and_takes_no_alarm(tmp_path):
|
||||
late = {"seen": NOW - timedelta(hours=40), "every": timedelta(hours=24)}
|
||||
partial = look(state(tmp_path, **late), [], now=NOW, res=None, full=False)
|
||||
assert not partial.full and partial.alarm is None
|
||||
assert "win=25/partial" in partial.ack
|
||||
assert "окно не дочитано" in partial.note
|
||||
# То же пустое окно, но дочитанное, - это показание, и оно даёт тревогу
|
||||
whole = look(state(tmp_path, **late), [], now=NOW, res=None, full=True)
|
||||
assert whole.alarm == "silence" and "win=25 " in whole.ack
|
||||
assert "сообщений комнаты: 0 из 25, история дочитана" in whole.note
|
||||
@@ -1,186 +0,0 @@
|
||||
import pytest
|
||||
from beaver_gateway.mcp.types import McpServer
|
||||
from beaver_gateway.mcp.wrap import build_python_tool_server
|
||||
from fastmcp import Client
|
||||
from fastmcp.exceptions import ToolError
|
||||
|
||||
from beaver_agent.hands.komodo import Komodo
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def server():
|
||||
tool = Komodo(url="http://127.0.0.1:9", key="k", secret="s")
|
||||
return build_python_tool_server(
|
||||
McpServer.python_tool(name="komodo", tools=[tool.komodo])
|
||||
)
|
||||
|
||||
|
||||
async def test_only_listed_actions_exist(server):
|
||||
async with Client(server) as client:
|
||||
(tool,) = await client.list_tools()
|
||||
actions = tool.inputSchema["properties"]["action"]["enum"]
|
||||
assert (
|
||||
"prune" not in actions
|
||||
and "destroy" not in actions
|
||||
and "terminal" not in actions
|
||||
)
|
||||
assert {"logs", "deploy", "restart", "exec"} <= set(actions)
|
||||
with pytest.raises(ToolError):
|
||||
await client.call_tool(
|
||||
"komodo", {"action": "prune", "stack": "beaver-agent"}
|
||||
)
|
||||
|
||||
|
||||
async def test_exec_denies_infrastructure_before_any_request(server):
|
||||
async with Client(server) as client:
|
||||
result = await client.call_tool(
|
||||
"komodo", {"action": "exec", "container": "dell-periphery", "command": "id"}
|
||||
)
|
||||
assert "запрещён" in result.content[0].text
|
||||
|
||||
|
||||
async def test_missing_parameter_is_an_error(server):
|
||||
async with Client(server) as client:
|
||||
with pytest.raises(ToolError, match="stack"):
|
||||
await client.call_tool("komodo", {"action": "logs"})
|
||||
|
||||
|
||||
def test_clip_keeps_head_and_tail():
|
||||
k = Komodo(url="u", key="k", secret="s", max_chars=30)
|
||||
out = k._clip("a" * 100)
|
||||
assert out.startswith("a" * 20) and out.endswith("a" * 10) and "обрезано" in out
|
||||
|
||||
|
||||
def fleet(answers, calls=None):
|
||||
"""Komodo, отвечающий заготовками; calls копит запросы к нему."""
|
||||
|
||||
class Fake(Komodo):
|
||||
async def read(self, request, params):
|
||||
if calls is not None:
|
||||
calls.append((request, params))
|
||||
answer = answers.get(request, [])
|
||||
return answer(params) if callable(answer) else answer
|
||||
|
||||
return Fake(url="u", key="k", secret="s")
|
||||
|
||||
|
||||
def a_stack(name, state="running", stack_id=None):
|
||||
return {
|
||||
"id": stack_id or name,
|
||||
"name": name,
|
||||
"info": {"state": state, "server_name": "dell-home"},
|
||||
}
|
||||
|
||||
|
||||
def an_update(operation="DeployStack", target_id="beaver-agent", ts=1_700_000_000_000):
|
||||
return {
|
||||
"id": f"upd-{ts}",
|
||||
"operation": operation,
|
||||
"start_ts": ts,
|
||||
"success": True,
|
||||
"status": "Complete",
|
||||
"username": "hh",
|
||||
"target": {"type": "Stack", "id": target_id},
|
||||
}
|
||||
|
||||
|
||||
async def test_a_short_page_is_not_the_whole_list():
|
||||
# Komodo режет List* до default_pagination_limit и молчит об этом.
|
||||
pages = [
|
||||
[a_stack(f"s{i}") for i in range(500)],
|
||||
[a_stack("zv-import"), a_stack("veris-runner")],
|
||||
]
|
||||
calls = []
|
||||
komodo = fleet({"ListStacks": lambda p: pages[p["page"]]}, calls)
|
||||
out = await komodo._stacks()
|
||||
assert [p["page"] for r, p in calls if r == "ListStacks"] == [0, 1]
|
||||
assert "zv-import" in out and "стеков: 502" in out
|
||||
|
||||
|
||||
async def test_status_says_when_the_not_running_list_is_cut():
|
||||
bad = [a_stack(f"b{i}", state="unknown") for i in range(23)]
|
||||
komodo = fleet({"ListStacks": bad, "ListServers": []})
|
||||
out = await komodo._status()
|
||||
assert "стеков: 23, не running: 23" in out
|
||||
assert "показаны 15 из 23, остальные скрыты лимитом" in out
|
||||
|
||||
komodo = fleet({"ListStacks": bad[:3], "ListServers": []})
|
||||
assert "скрыты лимитом" not in await komodo._status()
|
||||
|
||||
|
||||
async def test_both_listings_say_that_they_are_limited_by_rights():
|
||||
komodo = fleet({"ListStacks": [a_stack("beaver-agent")], "ListServers": []})
|
||||
assert "ограничен правами ключа" in await komodo._status()
|
||||
assert "ограничен правами ключа" in await komodo._stacks()
|
||||
|
||||
|
||||
async def test_updates_carry_the_shown_span_and_say_there_is_more():
|
||||
page = {
|
||||
"updates": [an_update(ts=1_700_000_000_000 - i * 60_000) for i in range(100)]
|
||||
}
|
||||
seen = {"ListStacks": [a_stack("beaver-agent")]}
|
||||
komodo = fleet(seen | {"ListUpdates": page | {"next_page": 1}})
|
||||
head, second, *lines = (await komodo._updates(15, None, None)).splitlines()
|
||||
assert head == "операций: 15, 11-14 21:59 … 11-14 22:13, раньше в журнале есть ещё"
|
||||
assert second == "фильтра нет: это просто хвост журнала"
|
||||
assert len(lines) == 15
|
||||
|
||||
komodo = fleet(
|
||||
seen | {"ListUpdates": {"updates": page["updates"][:3], "next_page": None}}
|
||||
)
|
||||
assert (await komodo._updates(15, None, None)).startswith(
|
||||
"операций: 3, 11-14 22:11 … 11-14 22:13, это весь журнал"
|
||||
)
|
||||
|
||||
|
||||
async def test_the_filter_goes_to_komodo_as_a_query():
|
||||
calls = []
|
||||
komodo = fleet(
|
||||
{
|
||||
"ListStacks": [a_stack("beaver-agent", stack_id="id-1")],
|
||||
"ListUpdates": {
|
||||
"updates": [an_update(target_id="id-1")],
|
||||
"next_page": None,
|
||||
},
|
||||
},
|
||||
calls,
|
||||
)
|
||||
out = await komodo._updates(15, "deploy", "beaver")
|
||||
(params,) = [p for r, p in calls if r == "ListUpdates"]
|
||||
assert params["query"] == {
|
||||
"operation": {"$regex": "deploy", "$options": "i"},
|
||||
"target.id": {"$in": ["id-1"]},
|
||||
}
|
||||
assert "фильтрует Komodo: операция ~deploy; ресурс ~beaver (1 шт)" in out
|
||||
# имя ресурса в строке, а не id
|
||||
assert "beaver-agent" in out and "id-1 " not in out
|
||||
|
||||
|
||||
async def test_an_unknown_name_is_said_out_loud_instead_of_filtering_by_nothing():
|
||||
komodo = fleet({"ListStacks": [a_stack("beaver-agent")]})
|
||||
out = await komodo._updates(15, None, "obsidian")
|
||||
assert out == (
|
||||
"ресурса ~obsidian ключу руки не видно: либо имя другое, либо он вне прав ключа"
|
||||
)
|
||||
|
||||
|
||||
async def test_a_target_the_key_cannot_see_is_counted_and_shown_by_id():
|
||||
komodo = fleet(
|
||||
{
|
||||
"ListStacks": [a_stack("beaver-agent", stack_id="id-1")],
|
||||
"ListUpdates": {
|
||||
"updates": [an_update(target_id="id-1"), an_update(target_id="gone")],
|
||||
"next_page": None,
|
||||
},
|
||||
}
|
||||
)
|
||||
out = await komodo._updates(15, None, None)
|
||||
assert "записей о невидимых ключу ресурсах: 1 - id вместо имени" in out
|
||||
assert "gone" in out
|
||||
|
||||
|
||||
async def test_the_depth_is_clamped_out_loud():
|
||||
komodo = fleet({"ListUpdates": {"updates": [], "next_page": None}})
|
||||
assert "запрошено 5000 записей, предел руки 200" in await komodo._updates(
|
||||
5000, None, None
|
||||
)
|
||||
@@ -1,86 +0,0 @@
|
||||
from datetime import timedelta
|
||||
|
||||
from beaver_agent.hands.komodo_alerts import (
|
||||
HOLD,
|
||||
AlertMemory,
|
||||
describe,
|
||||
parse,
|
||||
still_bad,
|
||||
)
|
||||
|
||||
|
||||
def alert(kind, *, resolved=False, level="CRITICAL", **data):
|
||||
data.setdefault("name", "ms-agents-proxy-aeza")
|
||||
return {"level": level, "resolved": resolved, "data": {"type": kind, "data": data}}
|
||||
|
||||
|
||||
def test_state_change_is_one_shot_and_read_by_target_state():
|
||||
up = parse(
|
||||
alert(
|
||||
"StackStateChange", resolved=True, **{"from": "running", "to": "unhealthy"}
|
||||
)
|
||||
)
|
||||
down = parse(
|
||||
alert(
|
||||
"StackStateChange", resolved=True, **{"from": "unhealthy", "to": "running"}
|
||||
)
|
||||
)
|
||||
assert up.bad and not down.bad
|
||||
assert up.key == down.key
|
||||
|
||||
|
||||
def test_flappy_alert_is_held_then_dropped_or_injected():
|
||||
mem = AlertMemory()
|
||||
first = parse(
|
||||
alert("ServerUnreachable", err={"error": "Timed out waiting for Ping"})
|
||||
)
|
||||
assert mem.verdict(first).action == "hold"
|
||||
# повтор той же тревоги, пока держим - тишина
|
||||
assert mem.verdict(first).action == "drop"
|
||||
# отбой во время выдержки - тоже тишина, и память чистая
|
||||
assert (
|
||||
mem.verdict(parse(alert("ServerUnreachable", resolved=True))).action == "drop"
|
||||
)
|
||||
assert not mem.holding and not mem.told
|
||||
# выдержка истекла, всё ещё плохо - срочно, и потом отбой доезжает
|
||||
mem.verdict(first)
|
||||
late = mem.after_hold(first, still_bad=True)
|
||||
assert (late.action, late.urgency) == ("inject", "urgent")
|
||||
mem.mark_told(first)
|
||||
assert (
|
||||
mem.verdict(parse(alert("ServerUnreachable", resolved=True))).action
|
||||
== "resolved"
|
||||
)
|
||||
assert not mem.told
|
||||
|
||||
|
||||
def test_informational_never_reaches_master_and_failures_go_normal():
|
||||
mem = AlertMemory()
|
||||
assert mem.verdict(parse(alert("StackImageUpdateAvailable"))).action == "drop"
|
||||
assert mem.verdict(parse(alert("ScheduleRun"))).action == "drop"
|
||||
failed = mem.verdict(parse(alert("ProcedureFailed", name="Fleet Backup")))
|
||||
assert (failed.action, failed.urgency) == ("inject", "normal")
|
||||
|
||||
|
||||
def test_describe_mentions_hold():
|
||||
a = parse(alert("ServerUnreachable", err={"error": "Timed out waiting for Ping"}))
|
||||
text = describe(a, held=HOLD)
|
||||
assert "ms-agents-proxy-aeza" in text and "5 мин" in text and "Timed out" in text
|
||||
assert describe(
|
||||
parse(alert("ServerDisk", name="dell", path="/", used_gb=90, total_gb=100))
|
||||
)
|
||||
|
||||
|
||||
async def test_still_bad_reads_current_state():
|
||||
async def read(kind, params):
|
||||
assert kind == "ListServers"
|
||||
return [{"name": "ms-agents-proxy-aeza", "info": {"state": "Ok"}}]
|
||||
|
||||
a = parse(alert("ServerUnreachable"))
|
||||
assert await still_bad(read, a) is False
|
||||
|
||||
async def boom(kind, params):
|
||||
raise RuntimeError("komodo down")
|
||||
|
||||
assert await still_bad(boom, a) is True
|
||||
assert HOLD == timedelta(minutes=5)
|
||||
@@ -1,813 +0,0 @@
|
||||
import json
|
||||
from datetime import UTC, datetime, timedelta
|
||||
|
||||
from beaver_agent.hands.komodo import Komodo
|
||||
from beaver_agent.hands.komodo_logs import (
|
||||
KEEP,
|
||||
MUTE_KINDS,
|
||||
MUTE_SHOW,
|
||||
SELF_MARK,
|
||||
SURGE_CEILING,
|
||||
SURGE_FACTOR,
|
||||
SURGE_MIN,
|
||||
Seen,
|
||||
StackScan,
|
||||
Sweep,
|
||||
brief,
|
||||
daily,
|
||||
digest,
|
||||
grouped,
|
||||
note,
|
||||
read_stack,
|
||||
record,
|
||||
)
|
||||
from beaver_agent.jobs.logs import sweep as sweep_fleet
|
||||
|
||||
NOW = datetime(2026, 9, 20, 18, 0, tzinfo=UTC)
|
||||
|
||||
|
||||
def log(*lines):
|
||||
return {"stdout": "\n".join(lines), "stderr": ""}
|
||||
|
||||
|
||||
def line(service, at, text):
|
||||
return f"{service} | {at}Z {text}"
|
||||
|
||||
|
||||
def a_stack(name, server="dell-home"):
|
||||
return {
|
||||
"id": name,
|
||||
"name": name,
|
||||
"info": {"state": "running", "server_name": server},
|
||||
}
|
||||
|
||||
|
||||
def fleet(answers, calls=None):
|
||||
"""Komodo, отвечающий заготовками; calls копит запросы к нему."""
|
||||
|
||||
class Fake(Komodo):
|
||||
async def read(self, request, params):
|
||||
if calls is not None:
|
||||
calls.append((request, params))
|
||||
answer = answers.get(request, [])
|
||||
return answer(params) if callable(answer) else answer
|
||||
|
||||
return Fake(url="u", key="k", secret="s")
|
||||
|
||||
|
||||
def swept(scans, **kw):
|
||||
kw.setdefault("in_scope", len(scans))
|
||||
kw.setdefault("fleet", len(scans))
|
||||
return Sweep(at=kw.pop("at", NOW), scans=tuple(scans), **kw)
|
||||
|
||||
|
||||
KNOWN = ("beaver-agent", "gitea", "democalc", "mix", "healthbot")
|
||||
|
||||
|
||||
def seen(tmp_path, *, fresh=False, known=KNOWN):
|
||||
"""Состояние с уже снятой базовой линией: проход не первый."""
|
||||
state = Seen.load(tmp_path / "логи.json")
|
||||
if not fresh:
|
||||
state.fresh = False
|
||||
state.baselined = set(known)
|
||||
return state
|
||||
|
||||
|
||||
def test_a_line_gives_its_service_its_time_and_its_signal():
|
||||
scan = read_stack(
|
||||
"beaver-agent",
|
||||
log(
|
||||
line("beaver-gateway", "2026-09-20T17:40:01.123456789", "ERROR boom"),
|
||||
line("beaver-gateway", "2026-09-20T17:41:02.000000000", "ERROR boom"),
|
||||
line("beaver-obsidian", "2026-09-20T17:42:03.000000000", "Fully synced"),
|
||||
),
|
||||
)
|
||||
(hit,) = scan.hits
|
||||
assert hit.service == "beaver-gateway"
|
||||
assert hit.signal == "ошибка"
|
||||
assert hit.count == 2
|
||||
assert hit.at == datetime(2026, 9, 20, 17, 41, 2, tzinfo=UTC)
|
||||
assert scan.first == datetime(2026, 9, 20, 17, 40, 1, 123456, tzinfo=UTC)
|
||||
assert scan.last == datetime(2026, 9, 20, 17, 42, 3, tzinfo=UTC)
|
||||
|
||||
|
||||
def test_the_same_trouble_with_other_numbers_is_the_same_trouble():
|
||||
scan = read_stack(
|
||||
"gitea",
|
||||
log(
|
||||
line("gitea", "2026-09-20T17:40:01.0", "ERROR request 8871 failed"),
|
||||
line("gitea", "2026-09-20T17:40:09.0", "ERROR request 9134 failed"),
|
||||
),
|
||||
)
|
||||
(hit,) = scan.hits
|
||||
assert hit.count == 2
|
||||
|
||||
|
||||
def test_every_named_signal_is_caught():
|
||||
texts = (
|
||||
"CRITICAL disk is gone",
|
||||
"panic: runtime error",
|
||||
"container OOMKilled",
|
||||
"Traceback (most recent call last):",
|
||||
"service exited with code 137",
|
||||
"beaver-gateway Restarting (1) 3 seconds ago",
|
||||
"container is unhealthy",
|
||||
"ERROR plain",
|
||||
)
|
||||
scan = read_stack(
|
||||
"mix",
|
||||
log(*(line("svc", f"2026-09-20T17:4{i}:00.0", t) for i, t in enumerate(texts))),
|
||||
)
|
||||
assert {h.signal for h in scan.hits} == {
|
||||
"критично",
|
||||
"паника",
|
||||
"oom",
|
||||
"traceback",
|
||||
"падение",
|
||||
"рестарт-цикл",
|
||||
"healthcheck",
|
||||
"ошибка",
|
||||
}
|
||||
assert "exited with code 0" not in {h.sample for h in scan.hits}
|
||||
|
||||
|
||||
def test_a_clean_exit_and_our_own_inject_are_not_trouble():
|
||||
scan = read_stack(
|
||||
"beaver-agent",
|
||||
log(
|
||||
line("svc", "2026-09-20T17:40:00.0", "worker exited with code 0"),
|
||||
line("beaver-gateway", "2026-09-20T17:41:00.0", f"{SELF_MARK}: ERROR boom"),
|
||||
),
|
||||
)
|
||||
assert scan.hits == ()
|
||||
|
||||
|
||||
def test_komodos_own_error_is_not_a_clean_stack():
|
||||
scan = read_stack("gitea", {"error": "periphery unreachable"})
|
||||
assert not scan.ok
|
||||
assert scan.error == "periphery unreachable"
|
||||
assert Sweep(at=NOW, scans=(scan,), in_scope=1, fleet=1).trouble == (
|
||||
"gitea: periphery unreachable",
|
||||
)
|
||||
|
||||
|
||||
def test_the_first_pass_only_takes_the_baseline(tmp_path):
|
||||
state = seen(tmp_path, fresh=True)
|
||||
scan = read_stack(
|
||||
"beaver-agent", log(line("svc", "2026-09-20T17:40:00.0", "ERROR старая беда"))
|
||||
)
|
||||
report = digest(state, swept([scan]))
|
||||
assert report.cold and report.baseline == 1
|
||||
assert report.new == ()
|
||||
text = brief(report)
|
||||
assert "базовую линию" in text
|
||||
assert "прочитано 1 стеков из 1" in text
|
||||
|
||||
|
||||
def test_only_the_new_line_wakes_the_master(tmp_path):
|
||||
old = line("svc", "2026-09-20T17:40:00.0", "ERROR молотит третьи сутки")
|
||||
state = seen(tmp_path, fresh=True)
|
||||
first = digest(state, swept([read_stack("beaver-agent", log(old))]))
|
||||
state.mark_told(first)
|
||||
state.save()
|
||||
|
||||
fresh_line = line("svc", "2026-09-20T18:50:00.0", "CRITICAL диск кончился")
|
||||
state = Seen.load(tmp_path / "логи.json")
|
||||
report = digest(
|
||||
state,
|
||||
swept(
|
||||
[read_stack("beaver-agent", log(old, old, fresh_line))],
|
||||
at=NOW + timedelta(hours=3),
|
||||
),
|
||||
)
|
||||
(new,) = report.new
|
||||
assert new.signal == "критично"
|
||||
text = brief(report)
|
||||
assert "диск кончился" in text
|
||||
assert "молотит третьи сутки" not in text
|
||||
|
||||
|
||||
def test_a_repeat_carries_how_many_times(tmp_path):
|
||||
noisy = [
|
||||
line("svc", f"2026-09-20T17:4{i}:00.0", "ERROR раз за разом") for i in range(5)
|
||||
]
|
||||
report = digest(seen(tmp_path), swept([read_stack("beaver-agent", log(*noisy))]))
|
||||
assert "×5" in brief(report)
|
||||
|
||||
|
||||
def test_a_trouble_that_stopped_is_dated_by_the_event_not_by_the_look(tmp_path):
|
||||
was = line("svc", "2026-09-20T12:03:00.0", "ERROR было и прошло")
|
||||
state = seen(tmp_path)
|
||||
state.mark_told(digest(state, swept([read_stack("beaver-agent", log(was))])))
|
||||
|
||||
later = NOW + timedelta(hours=6)
|
||||
report = digest(state, swept([read_stack("beaver-agent", log())], at=later))
|
||||
(quiet,) = report.quiet
|
||||
assert quiet.last == datetime(2026, 9, 20, 12, 3, tzinfo=UTC)
|
||||
text = brief(report)
|
||||
assert "последнее в 20.09 12:03" in text
|
||||
assert f"{later:%H:%M}" not in text.split("\n", 1)[1]
|
||||
|
||||
|
||||
def test_a_stack_that_did_not_answer_is_not_a_stack_that_went_quiet(tmp_path):
|
||||
was = line("svc", "2026-09-20T12:03:00.0", "ERROR было")
|
||||
state = seen(tmp_path)
|
||||
state.mark_told(digest(state, swept([read_stack("beaver-agent", log(was))])))
|
||||
|
||||
report = digest(
|
||||
state,
|
||||
swept(
|
||||
[StackScan(stack="beaver-agent", error="timeout")],
|
||||
at=NOW + timedelta(hours=3),
|
||||
),
|
||||
)
|
||||
assert report.quiet == ()
|
||||
assert report.trouble == ("beaver-agent: timeout",)
|
||||
assert "beaver-agent: timeout" in brief(report)
|
||||
|
||||
|
||||
def test_an_undelivered_inject_leaves_the_trouble_new(tmp_path):
|
||||
scan = read_stack(
|
||||
"beaver-agent", log(line("svc", "2026-09-20T17:40:00.0", "ERROR боль"))
|
||||
)
|
||||
state = seen(tmp_path)
|
||||
first = digest(state, swept([scan]))
|
||||
assert len(first.new) == 1
|
||||
state.save() # инжект не доехал: mark_told не звали
|
||||
|
||||
state = Seen.load(state.path)
|
||||
again = digest(
|
||||
state, swept([read_stack("beaver-agent", log())], at=NOW + timedelta(hours=3))
|
||||
)
|
||||
assert [e.sample for e in again.new] == [e.sample for e in first.new]
|
||||
assert again.quiet == ()
|
||||
|
||||
|
||||
def test_the_state_survives_a_restart(tmp_path):
|
||||
scan = read_stack(
|
||||
"beaver-agent", log(line("svc", "2026-09-20T17:40:00.0", "ERROR боль"))
|
||||
)
|
||||
state = seen(tmp_path)
|
||||
state.mark_told(digest(state, swept([scan])))
|
||||
state.save()
|
||||
|
||||
state = Seen.load(state.path)
|
||||
assert not state.fresh
|
||||
report = digest(state, swept([scan], at=NOW + timedelta(hours=3)))
|
||||
assert report.new == () and report.quiet == ()
|
||||
|
||||
|
||||
def test_an_old_line_still_lying_in_the_tail_is_not_new_again(tmp_path):
|
||||
# Тихий стек держит августовскую строку в хвосте месяцами: она не новая.
|
||||
scan = read_stack(
|
||||
"democalc", log(line("pg-1", "2026-08-22T15:49:51.0", "ERROR: relation"))
|
||||
)
|
||||
state = seen(tmp_path)
|
||||
state.mark_told(digest(state, swept([scan])))
|
||||
state.save()
|
||||
|
||||
state = Seen.load(state.path)
|
||||
assert digest(state, swept([scan], at=NOW + timedelta(hours=3))).new == ()
|
||||
|
||||
|
||||
def test_a_trouble_forgotten_by_time_comes_back_as_new(tmp_path):
|
||||
scan = read_stack(
|
||||
"beaver-agent", log(line("svc", "2026-09-20T17:40:00.0", "ERROR боль"))
|
||||
)
|
||||
state = seen(tmp_path)
|
||||
state.mark_told(digest(state, swept([scan])))
|
||||
late = NOW + KEEP + timedelta(days=1)
|
||||
report = digest(state, swept([scan], at=late))
|
||||
assert len(report.new) == 1
|
||||
|
||||
|
||||
def test_a_silent_pass_is_not_worth_the_master(tmp_path):
|
||||
state = seen(tmp_path)
|
||||
assert not digest(state, swept([read_stack("beaver-agent", log())])).worth_telling
|
||||
|
||||
|
||||
def test_the_scope_says_how_much_was_looked_at(tmp_path):
|
||||
scans = [
|
||||
read_stack(
|
||||
"beaver-agent", log(line("svc", "2026-09-20T17:40:00.0", "ERROR боль"))
|
||||
),
|
||||
StackScan(stack="gitea", error="timeout"),
|
||||
]
|
||||
report = digest(seen(tmp_path), swept(scans, in_scope=2, fleet=53))
|
||||
head = brief(report).splitlines()[1]
|
||||
assert head.startswith(
|
||||
"Область: dell-home, personal-main - прочитано 1 стеков из 2"
|
||||
)
|
||||
assert "во флоте 53" in head
|
||||
assert "хвост 2000 строк на стек: строки с 20.09 17:40 по 20.09 17:40" in head
|
||||
assert "самый короткий хвост у beaver-agent - только с 20.09 17:40" in head
|
||||
|
||||
|
||||
def test_a_tail_shorter_than_the_pause_between_passes_is_said_out_loud(tmp_path):
|
||||
state = seen(tmp_path)
|
||||
state.last_pass = NOW - timedelta(hours=3)
|
||||
scan = read_stack(
|
||||
"beaver-agent",
|
||||
log(line("svc", "2026-09-20T17:59:00.0", "ERROR из последней минуты")),
|
||||
)
|
||||
report = digest(state, swept([scan]))
|
||||
assert report.gaps == ("beaver-agent",)
|
||||
assert "часть строк прошла мимо" in brief(report)
|
||||
|
||||
|
||||
def test_a_silent_komodo_says_so_instead_of_reporting_clean(tmp_path):
|
||||
down = Sweep(at=NOW, unreachable="ClientError: connection refused")
|
||||
report = digest(seen(tmp_path), down)
|
||||
assert report.worth_telling
|
||||
text = brief(report)
|
||||
assert "Komodo не ответил" in text
|
||||
assert "Нового в этой области нет" not in text
|
||||
|
||||
|
||||
def test_a_lasting_outage_is_told_once(tmp_path):
|
||||
down = Sweep(at=NOW, unreachable="ClientError: connection refused")
|
||||
state = seen(tmp_path)
|
||||
state.mark_told(digest(state, down))
|
||||
assert digest(state, down).trouble == ()
|
||||
|
||||
|
||||
async def test_the_sweep_lists_every_page_and_skips_other_peoples_machines():
|
||||
pages = [
|
||||
[a_stack(f"s{i}") for i in range(500)],
|
||||
[a_stack("gitea", "personal-main"), a_stack("veris-runner", "veris-main")],
|
||||
]
|
||||
calls = []
|
||||
komodo = fleet(
|
||||
{
|
||||
"ListStacks": lambda p: pages[p["page"]],
|
||||
"GetStacksSummary": {"total": 502},
|
||||
"GetStackLog": log(),
|
||||
},
|
||||
calls,
|
||||
)
|
||||
out = await sweep_fleet(komodo, now=NOW)
|
||||
asked = [p["stack"] for r, p in calls if r == "GetStackLog"]
|
||||
assert "veris-runner" not in asked
|
||||
assert "gitea" in asked and "s0" in asked
|
||||
assert out.fleet == 502 and out.in_scope == 501
|
||||
assert out.trouble == ()
|
||||
assert all(p.get("timestamps") for r, p in calls if r == "GetStackLog")
|
||||
|
||||
|
||||
async def test_the_sweep_shouts_when_the_list_and_the_summary_disagree():
|
||||
komodo = fleet(
|
||||
{
|
||||
"ListStacks": [a_stack("beaver-agent")],
|
||||
"GetStacksSummary": {"total": 53},
|
||||
"GetStackLog": log(),
|
||||
}
|
||||
)
|
||||
out = await sweep_fleet(komodo, now=NOW)
|
||||
assert out.trouble == (
|
||||
"листание дало 1 стеков, а GetStacksSummary - 53: список неполон",
|
||||
)
|
||||
|
||||
|
||||
async def test_a_stack_that_throws_does_not_end_the_sweep():
|
||||
def logs(params):
|
||||
if params["stack"] == "gitea":
|
||||
msg = "connection reset"
|
||||
raise RuntimeError(msg)
|
||||
return log(line("svc", "2026-09-20T17:40:00.0", "ERROR боль"))
|
||||
|
||||
komodo = fleet(
|
||||
{
|
||||
"ListStacks": [a_stack("beaver-agent"), a_stack("gitea", "personal-main")],
|
||||
"GetStacksSummary": {"total": 2},
|
||||
"GetStackLog": logs,
|
||||
}
|
||||
)
|
||||
out = await sweep_fleet(komodo, now=NOW)
|
||||
assert len(out.read) == 1
|
||||
assert out.trouble == ("gitea: RuntimeError: connection reset",)
|
||||
|
||||
|
||||
async def test_a_dead_komodo_makes_a_sweep_that_admits_it():
|
||||
class Dead(Komodo):
|
||||
async def read(self, request, params):
|
||||
msg = "connection refused"
|
||||
raise OSError(msg)
|
||||
|
||||
out = await sweep_fleet(Dead(url="u", key="k", secret="s"), now=NOW)
|
||||
assert out.read == ()
|
||||
assert out.unreachable == "OSError: connection refused"
|
||||
assert out.trouble == ("Komodo не ответил: OSError: connection refused",)
|
||||
|
||||
|
||||
def test_a_line_without_a_stamp_is_not_a_find():
|
||||
# Голову хвоста Komodo обрезает по месту: полстроки - не новая беда.
|
||||
scan = read_stack(
|
||||
"democalc",
|
||||
log(
|
||||
"49.260 UTC [8772] ERROR: relation does not exist",
|
||||
line("postgres-1", "2026-09-20T17:40:00.0", "ERROR: настоящая"),
|
||||
),
|
||||
)
|
||||
assert [h.sample for h in scan.hits] == ["ERROR: настоящая"]
|
||||
assert scan.unparsed == 1 and scan.lines == 1
|
||||
|
||||
|
||||
def test_many_unreadable_lines_are_said_out_loud(tmp_path):
|
||||
scan = StackScan(stack="beaver-agent", lines=5, unparsed=40)
|
||||
head = brief(digest(seen(tmp_path), swept([scan]))).splitlines()[1]
|
||||
assert "строк без метки времени пропущено 40" in head
|
||||
|
||||
|
||||
def test_an_empty_line_is_a_line_not_a_blind_spot():
|
||||
scan = read_stack("dell-home-dawarich", log("app-1 | 2026-09-17T14:37:38.510Z"))
|
||||
assert scan.unparsed == 0 and scan.lines == 1 and scan.hits == ()
|
||||
|
||||
|
||||
def test_a_stack_read_for_the_first_time_does_not_dump_its_past(tmp_path):
|
||||
state = seen(tmp_path)
|
||||
scan = read_stack(
|
||||
"lodge", log(line("svc", "2026-09-19T10:00:00.0", "ERROR старое, до нас"))
|
||||
)
|
||||
report = digest(state, swept([scan]))
|
||||
assert report.new == ()
|
||||
assert report.baselined == ("lodge",) and report.baseline == 1
|
||||
assert "Впервые прочитаны" in brief(report)
|
||||
|
||||
later = read_stack(
|
||||
"lodge",
|
||||
log(
|
||||
line("svc", "2026-09-19T10:00:00.0", "ERROR старое, до нас"),
|
||||
line("svc", "2026-09-20T19:00:00.0", "ERROR уже при нас"),
|
||||
),
|
||||
)
|
||||
after = digest(state, swept([later], at=NOW + timedelta(hours=3)))
|
||||
assert [e.sample for e in after.new] == ["ERROR уже при нас"]
|
||||
|
||||
|
||||
def test_a_first_pass_into_a_dead_komodo_does_not_burn_the_baseline(tmp_path):
|
||||
state = seen(tmp_path, fresh=True)
|
||||
down = Sweep(at=NOW, unreachable="OSError: connection refused")
|
||||
report = digest(state, down)
|
||||
assert not report.cold and state.fresh
|
||||
assert report.trouble == ("Komodo не ответил: OSError: connection refused",)
|
||||
|
||||
scan = read_stack(
|
||||
"beaver-agent", log(line("svc", "2026-09-20T17:40:00.0", "ERROR боль"))
|
||||
)
|
||||
later = digest(state, swept([scan], at=NOW + timedelta(hours=3)))
|
||||
assert later.cold and later.new == ()
|
||||
|
||||
|
||||
def test_a_named_secret_in_the_line_does_not_ride_into_the_chat():
|
||||
scan = read_stack(
|
||||
"gitea",
|
||||
log(line("svc", "2026-09-20T17:40:00.0", "ERROR auth failed token=ghp_ZZ123")),
|
||||
)
|
||||
(hit,) = scan.hits
|
||||
assert "ghp_ZZ123" not in hit.sample
|
||||
assert hit.sample.startswith("ERROR auth failed token=")
|
||||
|
||||
|
||||
def test_a_bare_blob_stays_readable():
|
||||
# Размен с открытыми глазами: id задач, сессий и коммитов - это сигнал,
|
||||
# и замазывать их ради редкого безымянного ключа дороже, чем оставить.
|
||||
scan = read_stack(
|
||||
"komodo",
|
||||
log(line("svc", "2026-09-20T17:40:00.0", "ERROR task kJ8sdfLKJ23kjhsdf98234x")),
|
||||
)
|
||||
(hit,) = scan.hits
|
||||
assert "kJ8sdfLKJ23kjhsdf98234x" in hit.sample
|
||||
|
||||
|
||||
def stamps(day, hour, count, start=0):
|
||||
return [
|
||||
f"2026-09-{day:02d}T{hour:02d}:{m:02d}:00.0"
|
||||
for m in range(start, start + count)
|
||||
]
|
||||
|
||||
|
||||
def burst(stack, times, text="ERROR всё та же беда", service="svc"):
|
||||
"""Хвост стека, где одна и та же беда повторилась в перечисленные минуты."""
|
||||
return read_stack(stack, log(*(line(service, t, text) for t in times)))
|
||||
|
||||
|
||||
def at(day, hour, minute=0):
|
||||
return datetime(2026, 9, day, hour, minute, tzinfo=UTC)
|
||||
|
||||
|
||||
def told(state, report):
|
||||
state.mark_told(report)
|
||||
return report
|
||||
|
||||
|
||||
def test_a_continuing_trouble_is_told_once_and_then_keeps_quiet(tmp_path):
|
||||
state = seen(tmp_path)
|
||||
first = told(
|
||||
state, digest(state, swept([burst("gitea", stamps(20, 9, 3))], at=at(20, 10)))
|
||||
)
|
||||
assert len(first.new) == 1
|
||||
|
||||
# Хвост перечитан: те же строки плюс свежие - беда идёт, но новостью не стала.
|
||||
later = digest(
|
||||
state,
|
||||
swept([burst("gitea", stamps(20, 9, 3) + stamps(20, 12, 4))], at=at(20, 13)),
|
||||
)
|
||||
assert later.new == () and later.surge == () and later.quiet == ()
|
||||
assert not later.worth_telling
|
||||
assert later.ongoing == () # за прошлые сутки её ещё не было
|
||||
|
||||
|
||||
def test_the_reread_tail_does_not_inflate_the_count(tmp_path):
|
||||
state = seen(tmp_path)
|
||||
told(state, digest(state, swept([burst("gitea", stamps(20, 9, 3))], at=at(20, 10))))
|
||||
for hour in (13, 16, 19):
|
||||
digest(state, swept([burst("gitea", stamps(20, 9, 3))], at=at(20, hour)))
|
||||
(entry,) = state.entries.values()
|
||||
assert entry.count == 3 # три повтора, а не три на каждый из четырёх проходов
|
||||
assert entry.passes == 1
|
||||
|
||||
|
||||
def test_a_continuing_trouble_comes_back_in_the_daily_summary(tmp_path):
|
||||
state = seen(tmp_path)
|
||||
told(state, digest(state, swept([burst("gitea", stamps(20, 9, 5))], at=at(20, 10))))
|
||||
|
||||
# Первый проход следующих суток - 01:40, он же несёт сводку.
|
||||
night = digest(
|
||||
state,
|
||||
swept([burst("gitea", stamps(20, 9, 5) + stamps(21, 1, 2))], at=at(21, 1, 40)),
|
||||
)
|
||||
assert night.summary and len(night.ongoing) == 1
|
||||
assert night.new == () and not night.worth_telling
|
||||
text = daily(night, UTC)
|
||||
assert "сводка за 2026-09-20" in text # числа - про закрывшиеся сутки
|
||||
assert "gitea/svc ошибка, с 20.09 09:00, за сутки 5, первые сутки" in text
|
||||
assert "ERROR" not in text # образцов строк в сводке нет намеренно
|
||||
told(state, night)
|
||||
state.mark_daily(night)
|
||||
|
||||
# Тот же день, следующий проход: сводку уже отдали.
|
||||
again = digest(
|
||||
state,
|
||||
swept([burst("gitea", stamps(20, 9, 5) + stamps(21, 1, 2))], at=at(21, 4, 40)),
|
||||
)
|
||||
assert again.ongoing and not again.summary
|
||||
|
||||
|
||||
def test_the_summary_says_which_way_it_is_going(tmp_path):
|
||||
state = seen(tmp_path)
|
||||
told(state, digest(state, swept([burst("gitea", stamps(20, 9, 2))], at=at(20, 10))))
|
||||
day_two = swept(
|
||||
[burst("gitea", stamps(20, 9, 2) + stamps(21, 9, 8))], at=at(21, 10)
|
||||
)
|
||||
told(state, digest(state, day_two))
|
||||
third = digest(
|
||||
state,
|
||||
swept(
|
||||
[burst("gitea", stamps(20, 9, 2) + stamps(21, 9, 8) + stamps(22, 1, 1))],
|
||||
at=at(22, 1, 40),
|
||||
),
|
||||
)
|
||||
assert "за сутки 8, растёт (было 2)" in daily(third, UTC)
|
||||
|
||||
|
||||
def test_a_surge_of_the_familiar_breaks_the_silence(tmp_path):
|
||||
state = seen(tmp_path)
|
||||
state_report = digest(
|
||||
state, swept([burst("gitea", stamps(20, 9, 1))], at=at(20, 10))
|
||||
)
|
||||
told(state, state_report)
|
||||
for hour, minute in ((13, 12), (16, 15)):
|
||||
digest(
|
||||
state,
|
||||
swept([burst("gitea", stamps(20, hour - 1, 1, minute))], at=at(20, hour)),
|
||||
)
|
||||
(entry,) = state.entries.values()
|
||||
assert entry.passes == 3 and entry.norm == 1.0
|
||||
|
||||
spike = digest(state, swept([burst("gitea", stamps(20, 18, 12))], at=at(20, 19)))
|
||||
(item,) = spike.surge
|
||||
assert item.gain == 12 and item.norm == 1.0
|
||||
assert spike.new == () and spike.worth_telling
|
||||
text = brief(spike)
|
||||
assert "Всплеск знакомого (1)" in text
|
||||
assert "×12 за проход при норме ×1.0" in text
|
||||
assert "Нового в этой области нет" not in text
|
||||
|
||||
# Второй такой же проход внутри выдержки молчит: это уже не новость.
|
||||
told(state, spike)
|
||||
more = digest(state, swept([burst("gitea", stamps(20, 21, 12))], at=at(20, 22)))
|
||||
assert more.surge == () and not more.worth_telling
|
||||
|
||||
|
||||
def test_a_small_jump_is_not_a_surge(tmp_path):
|
||||
state = seen(tmp_path)
|
||||
told(state, digest(state, swept([burst("gitea", stamps(20, 9, 1))], at=at(20, 10))))
|
||||
for hour in (13, 16):
|
||||
digest(
|
||||
state,
|
||||
swept([burst("gitea", stamps(20, hour - 1, 1, hour))], at=at(20, hour)),
|
||||
)
|
||||
# Вчетверо больше, но всего четыре штуки: пол в SURGE_MIN держит тишину.
|
||||
small = digest(state, swept([burst("gitea", stamps(20, 18, 4))], at=at(20, 19)))
|
||||
assert small.surge == () and not small.worth_telling
|
||||
|
||||
|
||||
def test_a_trouble_gone_silent_is_reported_even_while_its_line_lingers(tmp_path):
|
||||
state = seen(tmp_path)
|
||||
tail = burst("gitea", stamps(20, 9, 2))
|
||||
told(state, digest(state, swept([tail], at=at(20, 10))))
|
||||
|
||||
# Сутки та же строка лежит в хвосте, новых событий нет.
|
||||
assert not digest(state, swept([tail], at=at(20, 22))).quiet
|
||||
stopped = digest(state, swept([tail], at=at(21, 12)))
|
||||
(gone,) = stopped.quiet
|
||||
assert gone.last == at(20, 9, 1)
|
||||
assert "последнее в 20.09 09:01" in brief(stopped)
|
||||
|
||||
told(state, stopped)
|
||||
assert digest(state, swept([tail], at=at(21, 16))).quiet == ()
|
||||
|
||||
|
||||
def test_a_trouble_that_returns_after_the_all_clear_is_new_again(tmp_path):
|
||||
state = seen(tmp_path)
|
||||
tail = burst("gitea", stamps(20, 9, 2))
|
||||
told(state, digest(state, swept([tail], at=at(20, 10))))
|
||||
told(state, digest(state, swept([tail], at=at(21, 12)))) # стихла
|
||||
|
||||
back = digest(
|
||||
state,
|
||||
swept([burst("gitea", stamps(20, 9, 2) + stamps(21, 18, 3))], at=at(21, 19)),
|
||||
)
|
||||
assert len(back.new) == 1 and back.worth_telling
|
||||
|
||||
|
||||
def test_the_background_of_the_baseline_never_claims_to_have_stopped(tmp_path):
|
||||
# Про фон, принятый в базовую линию, мастер не слышал - «стихло» про него врёт.
|
||||
state = seen(tmp_path, known=())
|
||||
state.fresh = False
|
||||
cold = digest(state, swept([burst("lodge", stamps(20, 9, 2))], at=at(20, 10)))
|
||||
assert cold.new == () and cold.baseline == 1
|
||||
gone = digest(state, swept([read_stack("lodge", log())], at=at(20, 13)))
|
||||
assert gone.quiet == () and not gone.worth_telling
|
||||
|
||||
|
||||
def test_the_summary_folds_the_variants_of_one_service_into_one_row(tmp_path):
|
||||
state = seen(tmp_path)
|
||||
# Разные по смыслу строки: отличие в одних цифрах - это одна и та же беда.
|
||||
variants = [
|
||||
burst("gitea", stamps(20, 9, 4), text=f"ERROR {what}")
|
||||
for what in ("push отклонён", "миграция не прошла", "ssh-ключ отвергнут")
|
||||
]
|
||||
told(state, digest(state, swept(variants, at=at(20, 10))))
|
||||
night = digest(state, swept(variants, at=at(21, 1, 40)))
|
||||
(row,) = grouped(night.ongoing)
|
||||
assert row.kinds == 3 and row.day_before == 12
|
||||
text = daily(night, UTC)
|
||||
assert "Идёт до сих пор: 1 рядов (3 разных строк)" in text
|
||||
assert "gitea/svc ошибка, строк 3 видов, с 20.09 09:00, за сутки 12" in text
|
||||
|
||||
|
||||
def test_the_daily_summary_arrives_even_when_all_is_quiet(tmp_path):
|
||||
# Мёртвый джоб и чистый флот должны выглядеть по-разному.
|
||||
state = seen(tmp_path)
|
||||
for hour in (10, 13, 16, 19, 22):
|
||||
digest(state, swept([read_stack("gitea", log())], at=at(20, hour)))
|
||||
night = digest(state, swept([read_stack("gitea", log())], at=at(21, 1, 40)))
|
||||
assert night.summary and night.ongoing == ()
|
||||
assert not night.worth_telling # обычного инжекта нет, суточный - есть
|
||||
text = daily(night, UTC)
|
||||
assert text.splitlines() == [
|
||||
"Логи флота: сводка за 2026-09-20.",
|
||||
"Проходов за сутки 5 из 8 ожидавшихся; в последнем прочитано 1 стеков "
|
||||
"из 1 в области (dell-home, personal-main).",
|
||||
"Длящегося нет: всё, о чём я говорил, стихло или не повторялось.",
|
||||
]
|
||||
|
||||
|
||||
def test_the_daily_summary_counts_the_refusals(tmp_path):
|
||||
state = seen(tmp_path)
|
||||
digest(state, swept([StackScan(stack="gitea", error="timeout")], at=at(20, 10)))
|
||||
digest(state, Sweep(at=at(20, 13), unreachable="OSError: нет связи"))
|
||||
night = digest(state, swept([read_stack("gitea", log())], at=at(21, 1, 40)))
|
||||
assert (
|
||||
"Отказов доступа за те сутки: чтений стеков 1, проходов без ответа Komodo 1"
|
||||
in daily(night, UTC)
|
||||
)
|
||||
|
||||
|
||||
def test_a_slowly_growing_trouble_still_breaks_through(tmp_path):
|
||||
# Варёная лягушка: норма замерла на молодости беды и за ростом не тянется.
|
||||
state = seen(tmp_path)
|
||||
told(state, digest(state, swept([burst("gitea", stamps(20, 8, 1))], at=at(20, 9))))
|
||||
counts = [1, 1, 2, 3, 4, 6, 9, 13]
|
||||
hour = 10
|
||||
seen_times = stamps(20, 8, 1)
|
||||
surged = []
|
||||
for n in counts:
|
||||
seen_times = seen_times + stamps(20, hour - 1, n, start=10)
|
||||
report = digest(state, swept([burst("gitea", seen_times)], at=at(20, hour)))
|
||||
if report.surge:
|
||||
surged.append((hour, report.surge[0].gain, report.surge[0].norm))
|
||||
told(state, report)
|
||||
hour += 1
|
||||
(entry,) = state.entries.values()
|
||||
assert entry.norm == 1.0 # заморожена по первым трём активным проходам
|
||||
assert surged and surged[0][1] >= SURGE_MIN
|
||||
assert surged[0][2] == 1.0
|
||||
|
||||
|
||||
def test_the_ceiling_fires_without_any_relative_norm(tmp_path):
|
||||
# Беда, чья собственная норма уже огромна: относительный порог её не возьмёт.
|
||||
state = seen(tmp_path)
|
||||
times = stamps(20, 8, 40)
|
||||
told(state, digest(state, swept([burst("gitea", times)], at=at(20, 9))))
|
||||
for hour in (12, 15):
|
||||
times = times + stamps(20, hour - 1, 40, start=10)
|
||||
digest(state, swept([burst("gitea", times)], at=at(20, hour)))
|
||||
(entry,) = state.entries.values()
|
||||
assert entry.norm == 40.0
|
||||
huge = stamps(20, 17, 55, start=0)
|
||||
spike = digest(state, swept([burst("gitea", times + huge)], at=at(20, 18)))
|
||||
(item,) = spike.surge
|
||||
assert item.gain == 55 # 55 < 4 × 40, взял потолок, а не кратность
|
||||
assert item.gain < SURGE_FACTOR * item.norm
|
||||
assert item.gain >= SURGE_CEILING
|
||||
assert "Всплеск знакомого (1)" in brief(spike)
|
||||
|
||||
|
||||
def test_the_journal_is_appended_and_survives_the_passes(tmp_path):
|
||||
# Состояние - снимок, истории в нём нет: пороги пересматривать по журналу.
|
||||
state = seen(tmp_path)
|
||||
path = tmp_path / "логи-флота.jsonl"
|
||||
times = stamps(20, 8, 2)
|
||||
for i, hour in enumerate((10, 13, 16)):
|
||||
times = times + stamps(20, hour - 1, 2, start=20)
|
||||
report = digest(state, swept([burst("gitea", times)], at=at(20, hour)))
|
||||
told(state, report)
|
||||
note(path, record(report, UTC) | {"pass_of_day": i + 1})
|
||||
|
||||
rows = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines()]
|
||||
assert len(rows) == 3
|
||||
assert [r["pass_of_day"] for r in rows] == [1, 2, 3]
|
||||
assert rows[0]["stacks"] == 1 and rows[0]["in_scope"] == 1
|
||||
assert rows[0]["new"] == 1 and rows[0]["misses"] == 0
|
||||
(trouble,) = rows[2]["troubles"]
|
||||
assert trouble["where"] == "gitea/svc" and trouble["gain"] == 2
|
||||
assert trouble["total"] == 8 and trouble["day"] == 8
|
||||
|
||||
|
||||
def test_the_journal_turns_over_instead_of_growing_forever(tmp_path):
|
||||
path = tmp_path / "логи-флота.jsonl"
|
||||
for i in range(4):
|
||||
note(path, {"n": i, "padding": "x" * 200}, max_bytes=300)
|
||||
fresh = [json.loads(ln) for ln in path.read_text(encoding="utf-8").splitlines()]
|
||||
turned = [
|
||||
json.loads(ln)
|
||||
for ln in path.with_suffix(".jsonl.1").read_text(encoding="utf-8").splitlines()
|
||||
]
|
||||
assert [r["n"] for r in turned] == [0, 1] # старое уехало в .1, не пропало
|
||||
assert [r["n"] for r in fresh] == [2, 3]
|
||||
|
||||
|
||||
def test_a_storm_of_new_kinds_is_folded_into_one_loud_line(tmp_path):
|
||||
state = seen(tmp_path)
|
||||
flood = [
|
||||
burst("gitea", stamps(20, 9, 1, start=i), text=f"ERROR сбой {chr(1072 + i)}щ")
|
||||
for i in range(MUTE_KINDS + 5)
|
||||
]
|
||||
report = digest(state, swept(flood, at=at(20, 10)))
|
||||
(storm,) = report.storms
|
||||
assert storm.kinds == MUTE_KINDS + 5 and storm.shown == MUTE_SHOW
|
||||
assert len(report.new) == MUTE_SHOW # остальное проглочено, но посчитано
|
||||
text = brief(report)
|
||||
assert "глушу" in text
|
||||
assert f"Стек gitea: {MUTE_KINDS + 5} новых ВИДОВ строк за проход" in text
|
||||
assert report.worth_telling
|
||||
|
||||
# Пока не сказали - повторяем; сказали - в суточной сводке.
|
||||
told(state, report)
|
||||
assert state.mutes["gitea"].told
|
||||
assert state.mutes["gitea"].kinds == 5 + MUTE_KINDS - MUTE_SHOW
|
||||
|
||||
|
||||
def test_the_muted_stack_is_named_once_a_day_until_it_calms_down(tmp_path):
|
||||
state = seen(tmp_path)
|
||||
flood = [
|
||||
burst("gitea", stamps(20, 9, 1, start=i), text=f"ERROR сбой {chr(1072 + i)}щ")
|
||||
for i in range(MUTE_KINDS + 5)
|
||||
]
|
||||
told(state, digest(state, swept(flood, at=at(20, 10))))
|
||||
night = digest(state, swept(flood, at=at(21, 1, 40)))
|
||||
assert "Приглушён gitea" in daily(night, UTC)
|
||||
assert "глушу с 20.09 10:00" in daily(night, UTC)
|
||||
|
||||
calm = digest(state, swept([burst("gitea", stamps(21, 9, 2))], at=at(21, 10)))
|
||||
assert calm.unmuted == ("gitea",) and "глушение снял: gitea" in brief(calm)
|
||||
assert "gitea" not in state.mutes
|
||||
|
||||
|
||||
def test_the_first_sighting_is_never_a_surge(tmp_path):
|
||||
# В хвосте лежит суточный запас: первый счёт - про длину хвоста, не про беду.
|
||||
state = seen(tmp_path, fresh=True)
|
||||
loud = digest(state, swept([burst("gitea", stamps(20, 9, 55))], at=at(20, 10)))
|
||||
assert loud.surge == () and loud.cold and loud.baseline == 1
|
||||
@@ -1,206 +0,0 @@
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from zoneinfo import ZoneInfo
|
||||
|
||||
from beaver_agent.jobs.leisure import (
|
||||
EMPTY_DEFAULT,
|
||||
MINE_MIN,
|
||||
QUIET_TICKS,
|
||||
Plan,
|
||||
brief,
|
||||
day_of,
|
||||
echo,
|
||||
enabled,
|
||||
kind_of,
|
||||
plan_of,
|
||||
quiet_hour,
|
||||
tick_hours,
|
||||
)
|
||||
from beaver_agent.vault import VAULT
|
||||
|
||||
ZONE = ZoneInfo("Europe/Warsaw")
|
||||
|
||||
|
||||
def at(text: str) -> datetime:
|
||||
return datetime.fromisoformat(text).replace(tzinfo=ZONE)
|
||||
|
||||
|
||||
def test_switch_defaults_to_on_and_only_explicit_off_stops_it():
|
||||
assert enabled(None)
|
||||
assert enabled("# досуг\n\nничего про выключатель")
|
||||
assert enabled("досуг: вкл")
|
||||
assert not enabled("# досуг\n\nдосуг: выкл\nсутки: 2026-09-08")
|
||||
assert not enabled("досуг: off")
|
||||
|
||||
|
||||
def test_day_starts_at_noon():
|
||||
assert day_of(at("2026-09-08 12:00")) == "2026-09-08"
|
||||
assert day_of(at("2026-09-08 23:30")) == "2026-09-08"
|
||||
assert day_of(at("2026-09-09 03:00")) == "2026-09-08"
|
||||
assert day_of(at("2026-09-09 11:59")) == "2026-09-08"
|
||||
assert day_of(at("2026-09-09 12:00")) == "2026-09-09"
|
||||
|
||||
|
||||
def test_active_window_ticks_hourly_and_quiet_window_only_by_plan():
|
||||
hours = tick_hours(QUIET_TICKS)
|
||||
assert hours[0] == 12
|
||||
assert len(hours) == 20
|
||||
assert all(h in hours for h in (12, 18, 23, 0, 3))
|
||||
assert [h for h in hours if quiet_hour(h)] == [4, 6, 8, 10]
|
||||
assert 5 not in hours and 11 not in hours
|
||||
assert tick_hours((5, 7))[-2:] == (5, 7)
|
||||
|
||||
|
||||
def test_plan_is_read_from_the_file_for_todays_day_only():
|
||||
text = (
|
||||
"# досуг\n\n"
|
||||
"досуг: вкл\n"
|
||||
"сутки: 2026-09-08\n"
|
||||
"тихие часы: 05, 07, 09, 11\n"
|
||||
"мои часы: 13, 16, 19, 22, 01, 05, 09\n"
|
||||
)
|
||||
plan = plan_of(text, "2026-09-08")
|
||||
assert plan.written
|
||||
assert plan.quiet == (5, 7, 9, 11)
|
||||
assert plan.mine == (13, 16, 19, 22, 1, 5, 9)
|
||||
|
||||
stale = plan_of(text, "2026-09-09")
|
||||
assert not stale.written
|
||||
assert stale.quiet == QUIET_TICKS
|
||||
|
||||
|
||||
def test_missing_plan_falls_back_to_defaults():
|
||||
plan = plan_of(None, "2026-09-08")
|
||||
assert not plan.written
|
||||
assert plan.quiet == QUIET_TICKS
|
||||
assert len(plan.mine) == MINE_MIN
|
||||
assert set(plan.mine) <= set(tick_hours(plan.quiet))
|
||||
|
||||
|
||||
def test_short_plan_is_topped_up_to_the_guaranteed_minimum():
|
||||
text = "сутки: 2026-09-08\nмои часы: 14, 20\n"
|
||||
plan = plan_of(text, "2026-09-08")
|
||||
assert plan.written
|
||||
assert len(plan.mine) == MINE_MIN
|
||||
assert 14 in plan.mine and 20 in plan.mine
|
||||
assert plan.mine == tuple(sorted(plan.mine, key=tick_hours(plan.quiet).index))
|
||||
|
||||
|
||||
def test_unreachable_hours_are_dropped_from_the_plan():
|
||||
text = "сутки: 2026-09-08\nтихие часы: 04, 06, 08, 10\nмои часы: 05, 11, 14\n"
|
||||
plan = plan_of(text, "2026-09-08")
|
||||
assert 5 not in plan.mine and 11 not in plan.mine
|
||||
assert 14 in plan.mine and len(plan.mine) == MINE_MIN
|
||||
|
||||
|
||||
def test_brief_names_the_type_and_counts_spent_slots():
|
||||
plan = Plan(
|
||||
day="2026-09-08",
|
||||
quiet=QUIET_TICKS,
|
||||
mine=(13, 15, 18, 21, 0, 2, 6),
|
||||
written=True,
|
||||
)
|
||||
text = brief(at("2026-09-08 18:00"), plan)
|
||||
assert "Тип: досуг" in text
|
||||
assert "израсходовано 3 из 7" in text
|
||||
assert "впереди 21, 00, 02, 06" in text
|
||||
assert "Сутки заканчиваются через 18 ч" in text
|
||||
assert "Задания нет" in text
|
||||
assert "Разложи" not in text
|
||||
|
||||
mixed = brief(at("2026-09-08 19:00"), plan)
|
||||
assert "Тип: смешанный" in mixed
|
||||
assert "израсходовано 3 из 7" in mixed
|
||||
|
||||
|
||||
def test_first_tick_of_the_day_is_the_planning_one():
|
||||
text = brief(at("2026-09-08 12:00"), plan_of(None, "2026-09-08"))
|
||||
assert "Первый тик суток" in text
|
||||
assert "расписания на эти сутки нет" in text.lower()
|
||||
assert str(MINE_MIN) in text
|
||||
|
||||
|
||||
def test_last_night_tick_says_nothing_is_left_ahead():
|
||||
plan = Plan(day="2026-09-08", quiet=QUIET_TICKS, mine=(13, 6), written=True)
|
||||
text = brief(at("2026-09-09 06:00"), plan)
|
||||
assert "впереди больше нет" in text
|
||||
assert "израсходовано 2 из 2" in text
|
||||
assert "Сутки заканчиваются через 6 ч" in text
|
||||
|
||||
|
||||
def test_two_of_my_hours_are_empty_named_or_not():
|
||||
named = plan_of(
|
||||
"сутки: 2026-09-08\nмои часы: 13, 15, 18, 21, 00, 02, 06\n"
|
||||
"пустые часы: 21, 02\n",
|
||||
"2026-09-08",
|
||||
)
|
||||
assert named.empty == (21, 2)
|
||||
|
||||
unnamed = plan_of(None, "2026-09-08")
|
||||
assert unnamed.empty == EMPTY_DEFAULT
|
||||
assert set(unnamed.empty) <= set(unnamed.mine)
|
||||
|
||||
foreign = plan_of(
|
||||
"сутки: 2026-09-08\nмои часы: 13, 14, 15, 16, 17, 19, 20\n"
|
||||
"пустые часы: 22, 20\n",
|
||||
"2026-09-08",
|
||||
)
|
||||
assert foreign.empty == (19, 20)
|
||||
assert kind_of(20, foreign) == "empty"
|
||||
assert kind_of(13, foreign) == "mine"
|
||||
assert kind_of(21, foreign) == "mixed"
|
||||
|
||||
|
||||
def test_an_empty_hour_carries_no_work_but_an_echo_and_the_files_of_the_day():
|
||||
plan = plan_of(None, "2026-09-08")
|
||||
heard = (VAULT / "мета" / "бобер" / "дневник" / "2026-08-30.md", "Раз.\nДва.")
|
||||
text = brief(at("2026-09-08 18:00"), plan, heard=heard)
|
||||
assert "Тип: пустой - час без дел вообще" in text
|
||||
assert "Пустые: 18, 00." in text
|
||||
assert "Эхо - `мета/бобер/дневник/2026-08-30.md`:\n> Раз.\n> Два.\n" in text
|
||||
assert "Дневник - `мета/бобер/дневник/2026-09-08.md`" in text
|
||||
assert "`мета/бобер/журнал/2026-09-08.md`" in text
|
||||
|
||||
night = brief(at("2026-09-09 00:00"), plan)
|
||||
assert "Тип: пустой" in night
|
||||
assert "мета/бобер/дневник/2026-09-09.md" in night
|
||||
assert "Эхо" not in night
|
||||
|
||||
mine = brief(at("2026-09-08 13:00"), plan)
|
||||
assert "Тип: досуг" in mine
|
||||
assert "мета/бобер/журнал/2026-09-08.md" in mine
|
||||
|
||||
|
||||
def test_echo_is_a_paragraph_of_an_old_diary_day_or_a_thought(tmp_path: Path):
|
||||
diary = tmp_path / "дневник"
|
||||
thoughts = tmp_path / "мысли" / "2026"
|
||||
diary.mkdir()
|
||||
thoughts.mkdir(parents=True)
|
||||
old = "Думал про то, зачем мне вообще помнить вчерашний день. " * 5
|
||||
fresh = "Свежая запись, которой ещё рано возвращаться ко мне эхом. " * 5
|
||||
(diary / "2026-08-30.md").write_text(
|
||||
f"## 2026-08-30, 01:07\n\n{old}\n\n- 02:07 30.08 лог, а не мысль {'x' * 220}\n"
|
||||
"\nкоротко\n",
|
||||
encoding="utf-8",
|
||||
)
|
||||
(diary / "2026-09-07.md").write_text(fresh, encoding="utf-8")
|
||||
now = at("2026-09-08 18:00")
|
||||
assert echo(now, diary=diary, thoughts=thoughts) == (
|
||||
diary / "2026-08-30.md",
|
||||
old.strip(),
|
||||
)
|
||||
|
||||
thought = "Заметка Бобра о том, почему скука полезнее расписания. " * 5
|
||||
(diary / "2026-08-30.md").unlink()
|
||||
(thoughts / "скука.md").write_text(
|
||||
f"---\ntags: [мысли]\n---\n\n{thought}\n", encoding="utf-8"
|
||||
)
|
||||
assert echo(now, diary=diary, thoughts=thoughts) == (
|
||||
thoughts / "скука.md",
|
||||
thought.strip(),
|
||||
)
|
||||
assert echo(now, diary=diary, thoughts=thoughts) == echo(
|
||||
now, diary=diary, thoughts=thoughts
|
||||
)
|
||||
(thoughts / "скука.md").unlink()
|
||||
assert echo(now, diary=diary, thoughts=thoughts) is None
|
||||
@@ -1,205 +0,0 @@
|
||||
import shutil
|
||||
import tempfile
|
||||
from collections.abc import Iterator
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
from beaver_gateway.agents.policy import Deny, ToolCall
|
||||
|
||||
from beaver_agent.policy import (
|
||||
Zones,
|
||||
bash_zones,
|
||||
forbid_skills,
|
||||
requires_skill,
|
||||
skill_tracker,
|
||||
vault_zones,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def vault() -> Iterator[Path]:
|
||||
root = Path(tempfile.mkdtemp(prefix="beaver-vault-"))
|
||||
try:
|
||||
for d in ("мета/бобер", "💬 чаты", "📅 дни", "👤 люди"):
|
||||
(root / d).mkdir(parents=True)
|
||||
(root / "💬 чаты/старый.md").write_text("x")
|
||||
(root / "📅 дни/2026-08-29.md").write_text("x")
|
||||
yield root
|
||||
finally:
|
||||
shutil.rmtree(root, ignore_errors=True)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def zones(vault: Path) -> Zones:
|
||||
return Zones(
|
||||
vault=vault, write=(vault / "мета/бобер",), create=(vault / "💬 чаты",)
|
||||
)
|
||||
|
||||
|
||||
def call(
|
||||
vault: Path, tool: str, state=None, kind: str = "master", **tool_input
|
||||
) -> ToolCall:
|
||||
return ToolCall(
|
||||
tool=tool,
|
||||
input=tool_input,
|
||||
agent="a",
|
||||
kind=kind,
|
||||
conversation="c",
|
||||
cwd=vault,
|
||||
state=state if state is not None else {},
|
||||
)
|
||||
|
||||
|
||||
def test_write_outside_zones_denied(vault, zones):
|
||||
rule = vault_zones(zones)
|
||||
deny = rule(call(vault, "Write", file_path=str(vault / "📅 дни/2026-08-29.md")))
|
||||
assert isinstance(deny, Deny) and "мета/бобер" in deny.reason
|
||||
assert rule(call(vault, "Edit", file_path=str(vault / "👤 люди/x.md"))) is not None
|
||||
assert rule(call(vault, "Write", file_path="новое.md")) is not None
|
||||
|
||||
|
||||
def test_zones_allow_and_create_only(vault, zones):
|
||||
rule = vault_zones(zones)
|
||||
assert (
|
||||
rule(call(vault, "Write", file_path=str(vault / "мета/бобер/дни/x.md"))) is None
|
||||
)
|
||||
assert rule(call(vault, "Edit", file_path="мета/бобер/состояние.md")) is None
|
||||
assert rule(call(vault, "Write", file_path=str(vault / "💬 чаты/новый.md"))) is None
|
||||
assert (
|
||||
rule(call(vault, "Write", file_path=str(vault / "💬 чаты/старый.md")))
|
||||
is not None
|
||||
)
|
||||
assert (
|
||||
rule(call(vault, "Edit", file_path=str(vault / "💬 чаты/новый.md"))) is not None
|
||||
)
|
||||
assert rule(call(vault, "Read", file_path=str(vault / "📅 дни/x.md"))) is None
|
||||
assert rule(call(vault, "Write", file_path="/tmp/scratch.md")) is None
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"command",
|
||||
[
|
||||
"rm '📅 дни/2026-08-29.md'",
|
||||
"rm -rf 👤\\ люди",
|
||||
"mv '👤 люди/x.md' 'мета/бобер/x.md'",
|
||||
"cp мета/бобер/x.md '📅 дни/y.md'",
|
||||
"echo hi > '📅 дни/today.md'",
|
||||
"cat a.md | tee '💬 чаты/старый.md'",
|
||||
"sed -i 's/a/b/' '👤 люди/x.md'",
|
||||
"cd 👤\\ люди && rm x.md",
|
||||
"ls; touch new.md",
|
||||
],
|
||||
)
|
||||
def test_bash_mutations_outside_zones_denied(vault, zones, command):
|
||||
deny = bash_zones(zones)(call(vault, "Bash", command=command))
|
||||
assert isinstance(deny, Deny), command
|
||||
assert deny.reason.startswith("Bash: ")
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"command",
|
||||
[
|
||||
"cat '👤 люди/x.md' | grep foo",
|
||||
"rm мета/бобер/дни/old.md",
|
||||
"echo hi > мета/бобер/x.md 2>&1",
|
||||
"cp '👤 люди/x.md' мета/бобер/копия.md",
|
||||
"sed 's/a/b/' '👤 люди/x.md'",
|
||||
"echo hi > '💬 чаты/новый.md'",
|
||||
"rm /tmp/x && ls > /dev/null",
|
||||
"python3 -c \"print('x')\" >> /tmp/log",
|
||||
"grep -r 'x' . --include='*.md'",
|
||||
],
|
||||
)
|
||||
def test_bash_reads_and_zone_writes_allowed(vault, zones, command):
|
||||
assert bash_zones(zones)(call(vault, "Bash", command=command)) is None, command
|
||||
|
||||
|
||||
def test_bash_unbalanced_quotes_fall_back(vault, zones):
|
||||
assert bash_zones(zones)(call(vault, "Bash", command='rm "📅')) is not None
|
||||
|
||||
|
||||
def test_firefly_requires_open_skill(vault):
|
||||
state = {}
|
||||
tracker, gate = (
|
||||
skill_tracker(),
|
||||
requires_skill("firefly", ("mcp__firefly__store_*",)),
|
||||
)
|
||||
store = call(vault, "mcp__firefly__store_transaction", state=state, data={})
|
||||
assert isinstance(gate(store), Deny)
|
||||
assert gate(call(vault, "mcp__firefly__list_account", state=state)) is None
|
||||
tracker(call(vault, "Skill", state=state, skill="vault:firefly"))
|
||||
assert gate(store) is None
|
||||
|
||||
|
||||
def test_forbid_skills_only_named_kinds_and_only_skill_tool(vault):
|
||||
rule = forbid_skills(("firefly", "beaver *"), kinds=("master", "job"))
|
||||
deny = rule(call(vault, "Skill", skill="vault:firefly"))
|
||||
assert isinstance(deny, Deny)
|
||||
assert deny.reason == "скилл firefly недоступен в master: открой ветку"
|
||||
assert rule(call(vault, "Skill", kind="job", skill="Beaver Durden")) is not None
|
||||
assert rule(call(vault, "Skill", name="vault:FireFly")) is not None
|
||||
assert rule(call(vault, "Skill", kind="branch", skill="vault:firefly")) is None
|
||||
assert rule(call(vault, "Skill", skill="общие:заметки")) is None
|
||||
assert rule(call(vault, "Read", file_path="скиллы/vault/firefly/SKILL.md")) is None
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def home(vault: Path) -> Zones:
|
||||
"""Зоны диспетчера с 2026-08-30: vault - дом, удаление - только своё."""
|
||||
(vault / ".obsidian").mkdir()
|
||||
(vault / "мета/шаблоны").mkdir()
|
||||
return Zones(
|
||||
vault=vault,
|
||||
write=(vault / "мета/бобер",),
|
||||
create=(vault / "💬 чаты",),
|
||||
edit=(vault,),
|
||||
protected=(vault / ".obsidian", vault / "мета"),
|
||||
)
|
||||
|
||||
|
||||
def test_home_zones_allow_notes_but_protect_obsidian_and_meta(vault, home):
|
||||
rule = vault_zones(home)
|
||||
assert rule(call(vault, "Write", file_path=str(vault / "👤 люди/новый.md"))) is None
|
||||
assert (
|
||||
rule(call(vault, "Edit", file_path=str(vault / "📅 дни/2026-08-29.md"))) is None
|
||||
)
|
||||
assert rule(call(vault, "Write", file_path=str(vault / "мета/бобер/x.md"))) is None
|
||||
assert (
|
||||
rule(call(vault, "Edit", file_path=str(vault / "💬 чаты/старый.md")))
|
||||
is not None
|
||||
)
|
||||
deny = rule(call(vault, "Write", file_path=str(vault / ".obsidian/app.json")))
|
||||
assert isinstance(deny, Deny) and "Бобра" in deny.reason
|
||||
assert (
|
||||
rule(call(vault, "Edit", file_path=str(vault / "мета/шаблоны/x.md")))
|
||||
is not None
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"command",
|
||||
[
|
||||
"mv '👤 люди/x.md' '👤 люди/архив/x.md'",
|
||||
"echo hi >> '📅 дни/2026-08-29.md'",
|
||||
"sed -i 's/a/b/' '👤 люди/x.md'",
|
||||
"rm мета/бобер/дни/old.md",
|
||||
"mkdir '💻 проекты/новый'",
|
||||
],
|
||||
)
|
||||
def test_home_bash_edits_allowed(vault, home, command):
|
||||
assert bash_zones(home)(call(vault, "Bash", command=command)) is None, command
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
"command",
|
||||
[
|
||||
"rm '📅 дни/2026-08-29.md'",
|
||||
"rm -rf 👤\\ люди",
|
||||
"truncate -s 0 '👤 люди/x.md'",
|
||||
"echo x > .obsidian/app.json",
|
||||
"mv '👤 люди/x.md' мета/шаблоны/x.md",
|
||||
],
|
||||
)
|
||||
def test_home_bash_deletes_and_protected_denied(vault, home, command):
|
||||
deny = bash_zones(home)(call(vault, "Bash", command=command))
|
||||
assert isinstance(deny, Deny), command
|
||||
@@ -1,333 +0,0 @@
|
||||
from datetime import UTC, date, datetime
|
||||
from pathlib import Path
|
||||
|
||||
from beaver_gateway.conversations.texts import UserSaid
|
||||
from beaver_gateway.conversations.envelope import RecallContext
|
||||
|
||||
from beaver_agent.hands.calendars import Calendars, Event, Feed
|
||||
from beaver_agent.memory.curator import new_replies
|
||||
from beaver_agent.memory.recall import (
|
||||
LABEL,
|
||||
Recall,
|
||||
ReplyLog,
|
||||
frontmatter_aliases,
|
||||
mentions,
|
||||
notes_head,
|
||||
routine_names,
|
||||
)
|
||||
|
||||
|
||||
def _card(path: Path, aliases: list[str] | None = None) -> None:
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
fm = "aliases:\n" + "".join(f" - {a}\n" for a in aliases or [])
|
||||
path.write_text(
|
||||
f"---\n{fm}tags:\n - люди/друг\n---\n# 👤 {path.stem}\n", encoding="utf-8"
|
||||
)
|
||||
|
||||
|
||||
def _vault(tmp_path: Path, calendar: Calendars | None = None) -> Recall:
|
||||
people = tmp_path / "👤 люди"
|
||||
_card(people / "личное" / "Зина.md", ["Зина"])
|
||||
_card(people / "личное" / "Прохор.md", ["Прохор Тестов"])
|
||||
_card(
|
||||
people / "профессиональное" / "программирование" / "Фёдор Плюшкин.md",
|
||||
["Фёдор Плюшкин", "Фёдор"],
|
||||
)
|
||||
_card(people / "личное" / "архив" / "Глафира.md")
|
||||
_card(people / "личное" / "рандомы" / "Устинья Пример.md")
|
||||
diary = tmp_path / "📅 дни"
|
||||
diary.mkdir()
|
||||
(diary / "2026-08-31.md").write_text("с [[Зина|Зиной]] гуляли\n", encoding="utf-8")
|
||||
(diary / "2026-08-26.md").write_text(
|
||||
"[[Зина]] звонила, [[Фёдор Плюшкин|Фёдор]] рассказывал\n", encoding="utf-8"
|
||||
)
|
||||
(diary / "2026-08-13.md").write_text("обед с [[Зина|Зины]]\n", encoding="utf-8")
|
||||
(diary / "2026-08-01.md").write_text("[[Зина]] ещё раз\n", encoding="utf-8")
|
||||
notes = tmp_path / "мета" / "бобер" / "наблюдения"
|
||||
notes.mkdir(parents=True)
|
||||
(notes / "Зина - наблюдения.md").write_text(
|
||||
"# Зина - наблюдения\n\n## сейчас\n- просила перезвонить вечером 26.08\n"
|
||||
"- ждёт ответа про поездку до четверга\n\n## паттерны\n"
|
||||
"- переносит встречи: [[2026-08-10]], [[2026-08-26]]\n\n## факты\n\n## открытое\n\n"
|
||||
"## лента\n- 2026-08-26 · перенесла встречу на час · [[2026-08-26]]\n"
|
||||
"- 2026-08-31 · прислала список покупок · транскрипт\n",
|
||||
encoding="utf-8",
|
||||
)
|
||||
(notes / "Прохор - наблюдения.md").write_text(
|
||||
"# Прохор - наблюдения\n\n## сейчас\n\n## лента\n- 2026-08-07 · приехал · [[2026-08-07]]\n",
|
||||
encoding="utf-8",
|
||||
)
|
||||
boards = tmp_path / "📆 доски"
|
||||
boards.mkdir()
|
||||
(boards / "организация.md").write_text(
|
||||
"## повседнев\n\n- [ ] оплатить счёт за свет 📅 2026-09-01\n- [ ] купить лампочки 📅 2026-09-02\n"
|
||||
"- [ ] далеко 📅 2026-09-20\n- [x] сделано 📅 2026-08-30\n\n***\n\n## Archive\n\n- [ ] старое 📅 2025-01-01\n",
|
||||
encoding="utf-8",
|
||||
)
|
||||
return Recall(
|
||||
vault=tmp_path,
|
||||
people_dir=people,
|
||||
notes_dir=notes,
|
||||
diary_dir=diary,
|
||||
boards_dir=boards,
|
||||
tz="Europe/Warsaw",
|
||||
calendar=calendar,
|
||||
)
|
||||
|
||||
|
||||
def test_frontmatter_aliases_handles_empty_and_lists() -> None:
|
||||
assert frontmatter_aliases("---\naliases:\ntags:\n---\n# x") == ()
|
||||
assert frontmatter_aliases(
|
||||
"---\naliases:\n - Фёдор Плюшкин\n - Фёдор\ntags:\n---\n"
|
||||
) == ("Фёдор Плюшкин", "Фёдор")
|
||||
assert frontmatter_aliases("нет фронтматтера") == ()
|
||||
|
||||
|
||||
def test_mentions_by_case_and_link_but_archive_only_by_link(tmp_path: Path) -> None:
|
||||
recall = _vault(tmp_path)
|
||||
people = recall.people.all()
|
||||
names = [p.name for p in mentions("созвон с Фёдором, потом к Зине", people)]
|
||||
assert names == ["Фёдор Плюшкин", "Зина"]
|
||||
assert [p.name for p in mentions("Глафира опять написала", people)] == []
|
||||
assert [
|
||||
p.name for p in mentions("глянь [[Глафира]] и [[Устинья Пример]]", people)
|
||||
] == ["Глафира", "Устинья Пример"]
|
||||
assert [p.name for p in mentions("Прохором обсуждали", people)] == ["Прохор"]
|
||||
# "Ван"+2 буквы ловит "ванна" - цена падежей; на голое имя короче 4 букв не смотрим
|
||||
assert [
|
||||
p.name for p in mentions("машина без людей, эля тут ни при чём", people)
|
||||
] == []
|
||||
|
||||
|
||||
def test_block_points_to_card_notes_diary_and_deadlines_once(tmp_path: Path) -> None:
|
||||
recall = _vault(tmp_path)
|
||||
now = datetime(2026, 9, 1, 12, 0, tzinfo=UTC)
|
||||
block = recall.block(RecallContext(text="что там у Зины", kind="master", now=now))
|
||||
assert block is not None
|
||||
lines = block.splitlines()
|
||||
assert lines[0] == LABEL
|
||||
assert lines[1] == (
|
||||
"👤 Зина - карточка `👤 люди/личное/Зина.md`; записки "
|
||||
"`мета/бобер/наблюдения/Зина - наблюдения.md`: лента 2 стр., паттернов 1; "
|
||||
"дневник: [[2026-08-31]], [[2026-08-26]], [[2026-08-13]]; сейчас:"
|
||||
)
|
||||
assert lines[2:4] == [
|
||||
" - просила перезвонить вечером 26.08",
|
||||
" - ждёт ответа про поездку до четверга",
|
||||
]
|
||||
assert lines[4:] == [
|
||||
"📆 09-01 организация: оплатить счёт за свет",
|
||||
"📆 09-02 организация: купить лампочки",
|
||||
]
|
||||
artem = recall.person_line(
|
||||
next(p for p in recall.people.all() if p.name == "Прохор")
|
||||
)
|
||||
assert "лента 1 стр., последняя: 2026-08-07 · приехал" in artem
|
||||
assert "сейчас:" not in artem
|
||||
again = recall.block(RecallContext(text="и ещё про Зину", kind="master", now=now))
|
||||
assert again is not None and "📆" not in again
|
||||
branch = recall.block(RecallContext(text="Фёдор звонил", kind="branch", now=now))
|
||||
assert branch is not None
|
||||
assert (
|
||||
"записок нет (`мета/бобер/наблюдения/Фёдор Плюшкин - наблюдения.md`)" in branch
|
||||
)
|
||||
assert "дневник: [[2026-08-26]]" in branch
|
||||
assert (
|
||||
recall.block(RecallContext(text="просто привет", kind="branch", now=now))
|
||||
is None
|
||||
)
|
||||
|
||||
|
||||
def test_reply_log_appends_one_line_per_message_and_strips_seed(tmp_path: Path) -> None:
|
||||
log = ReplyLog(tmp_path / "реплики", tz="Europe/Warsaw")
|
||||
at = datetime(2026, 9, 1, 12, 4, tzinfo=UTC)
|
||||
log.write(
|
||||
UserSaid(
|
||||
conversation_id="c1",
|
||||
kind="master",
|
||||
title=None,
|
||||
text="привет\n\nты меня любишь",
|
||||
at=at,
|
||||
)
|
||||
)
|
||||
log.write(
|
||||
UserSaid(
|
||||
conversation_id="c2",
|
||||
kind="branch",
|
||||
title="крипто-карта",
|
||||
text="[сид: clean] branch, 2026-09-01.\n\nсравни Trustee и RedotPay",
|
||||
at=at,
|
||||
)
|
||||
)
|
||||
log.write(
|
||||
UserSaid(
|
||||
conversation_id="c3",
|
||||
kind="branch",
|
||||
title="x",
|
||||
text="[сид: brief] только сид",
|
||||
at=at,
|
||||
)
|
||||
)
|
||||
text = (tmp_path / "реплики" / "2026-09-01.md").read_text(encoding="utf-8")
|
||||
assert text.startswith("# реплики Бобра, 2026-09-01\n")
|
||||
assert text.endswith(
|
||||
"- 2026-09-01 14:04 · мастер · привет ⏎ ты меня любишь\n"
|
||||
"- 2026-09-01 14:04 · ветка «крипто-карта» (бриф) · "
|
||||
"сравни Trustee и RedotPay\n"
|
||||
)
|
||||
since = datetime(2026, 9, 1, 0, 0, tzinfo=UTC)
|
||||
# пометка брифа не мешает куратору разбирать строку
|
||||
assert new_replies(tmp_path / "реплики", since, "Europe/Warsaw") == [
|
||||
line for line in text.splitlines() if line.startswith("- ")
|
||||
]
|
||||
late = datetime(2026, 9, 1, 22, 30, tzinfo=UTC)
|
||||
log.write(
|
||||
UserSaid(conversation_id="c1", kind="master", title=None, text="ночь", at=late)
|
||||
)
|
||||
night = (tmp_path / "реплики" / "2026-09-02.md").read_text(encoding="utf-8")
|
||||
assert night.endswith("- 2026-09-02 00:30 · мастер · ночь\n")
|
||||
assert new_replies(tmp_path / "реплики", late, "Europe/Warsaw") == []
|
||||
assert new_replies(
|
||||
tmp_path / "реплики", datetime(2026, 9, 1, 13, tzinfo=UTC), "Europe/Warsaw"
|
||||
) == ["- 2026-09-02 00:30 · мастер · ночь"]
|
||||
|
||||
|
||||
def test_notes_head_picks_sections_for_the_seed(tmp_path: Path) -> None:
|
||||
recall = _vault(tmp_path)
|
||||
path = recall.notes_dir / "Зина - наблюдения.md"
|
||||
head = notes_head(path, ("сейчас", "паттерны"))
|
||||
assert head == (
|
||||
"## сейчас\n- просила перезвонить вечером 26.08\n"
|
||||
"- ждёт ответа про поездку до четверга\n"
|
||||
"## паттерны\n- переносит встречи: [[2026-08-10]], [[2026-08-26]]"
|
||||
)
|
||||
assert notes_head(path, ("факты",)) is None
|
||||
assert notes_head(recall.notes_dir / "нет.md", ("сейчас",)) is None
|
||||
short = notes_head(path, ("сейчас", "паттерны"), cap=2)
|
||||
assert short is not None and short.endswith("… ещё 3 строк в файле")
|
||||
|
||||
|
||||
def _ics(*events: str) -> str:
|
||||
body = "".join(f"BEGIN:VEVENT\n{e}\nEND:VEVENT\n" for e in events)
|
||||
return f"BEGIN:VCALENDAR\nVERSION:2.0\n{body}END:VCALENDAR\n"
|
||||
|
||||
|
||||
def _calendar(text: str | None) -> Calendars:
|
||||
"""Фид, который отдаёт готовый ical; None - фид, который падает."""
|
||||
|
||||
class Fake(Calendars):
|
||||
def fetch(self, url: str) -> str:
|
||||
if text is None:
|
||||
raise OSError("фид не ответил")
|
||||
return text
|
||||
|
||||
return Fake((Feed("личный", "https://cal.example/x.ics"),), tz="Europe/Warsaw")
|
||||
|
||||
|
||||
def _daily(title: str, clock: str) -> str:
|
||||
return f"SUMMARY:{title}\nDTSTART;TZID=Europe/Warsaw:20260902T{clock}\nRRULE:FREQ=DAILY"
|
||||
|
||||
|
||||
SINGLES = (
|
||||
"SUMMARY:Созвон\nDTSTART:20260902T160000Z",
|
||||
"SUMMARY:Врач\nDTSTART:20260903T090000Z",
|
||||
"SUMMARY:Analiza matematyczna II - Egzamin\nDTSTART;VALUE=DATE-TIME:20260905T110000\n"
|
||||
"DESCRIPTION:Sala: 3\\nA23 - CW\\n\nLOCATION:ul. Piotrowo 2\\, Poznań",
|
||||
"SUMMARY:за окном\nDTSTART:20260925T080000Z",
|
||||
)
|
||||
ROUTINE = (
|
||||
_daily("Завтрак", "080000"),
|
||||
_daily("Обед", "150000"),
|
||||
_daily("Ужин", "200000"),
|
||||
_daily("Перекус", "180000"),
|
||||
_daily("Wind down", "223000"),
|
||||
)
|
||||
BUSY = _ics(*SINGLES, *ROUTINE)
|
||||
|
||||
|
||||
def _section(recall: Recall, now: datetime, text: str = "привет") -> list[str]:
|
||||
block = recall.block(RecallContext(text=text, kind="master", now=now))
|
||||
assert block is not None
|
||||
return [ln for ln in block.splitlines() if "календар" in ln or ln.startswith(" -")]
|
||||
|
||||
|
||||
def test_calendar_shows_every_single_event_and_folds_the_daily_routine(
|
||||
tmp_path: Path,
|
||||
) -> None:
|
||||
recall = _vault(tmp_path, _calendar(BUSY))
|
||||
now = datetime(2026, 9, 1, 12, 0, tzinfo=UTC)
|
||||
lines = _section(recall, now)
|
||||
assert lines == [
|
||||
"🗓 календарь (7 дней), разовых 3, повседневных 31, данные на 2026-09-01 14:00:",
|
||||
" - 09-02 18:00 Созвон",
|
||||
" - 09-03 11:00 Врач",
|
||||
" - 09-05 11:00 Analiza matematyczna II - Egzamin · Sala: 3, ul. Piotrowo 2, Poznań",
|
||||
" - повседневных повторов: 31 (Завтрак, Обед, Перекус, Ужин, Wind down)",
|
||||
]
|
||||
# секция дневная, как и сроки досок: второй конверт за те же сутки её не несёт
|
||||
again = recall.block(RecallContext(text="и ещё", kind="master", now=now))
|
||||
assert again is None or "календарь" not in again
|
||||
|
||||
|
||||
def test_no_amount_of_routine_can_push_out_a_single_event(tmp_path: Path) -> None:
|
||||
noise = tuple(_daily(f"быт {i}", f"{i:02d}0000") for i in range(9, 24))
|
||||
recall = _vault(tmp_path, _calendar(_ics(*SINGLES, *noise)))
|
||||
now = datetime(2026, 9, 1, 12, 0, tzinfo=UTC)
|
||||
lines = _section(recall, now)
|
||||
assert lines[0].startswith("🗓 календарь (7 дней), разовых 3, повседневных 96")
|
||||
assert [ln for ln in lines if "Egzamin" in ln]
|
||||
assert (
|
||||
len([ln for ln in lines if ln.startswith(" - ")]) == 4
|
||||
) # 3 разовых + свёртка
|
||||
assert lines[-1].startswith(" - повседневных повторов: 96")
|
||||
assert "и др." in lines[-1]
|
||||
|
||||
|
||||
def test_routine_line_counts_and_names_up_to_five(tmp_path: Path) -> None:
|
||||
events = [
|
||||
Event(
|
||||
start=datetime(2026, 9, 2, 8, tzinfo=UTC),
|
||||
title=t,
|
||||
place="",
|
||||
all_day=False,
|
||||
routine=True,
|
||||
)
|
||||
for t in ("Завтрак", "Обед", "Завтрак", "Ужин")
|
||||
]
|
||||
assert routine_names(events) == "Завтрак, Обед, Ужин"
|
||||
assert routine_names(events, limit=2) == "Завтрак, Обед и др."
|
||||
|
||||
|
||||
def test_calendar_section_is_printed_even_when_the_week_is_empty(
|
||||
tmp_path: Path,
|
||||
) -> None:
|
||||
recall = _vault(
|
||||
tmp_path, _calendar(_ics("SUMMARY:потом\nDTSTART:20261101T080000Z"))
|
||||
)
|
||||
now = datetime(2026, 9, 1, 12, 0, tzinfo=UTC)
|
||||
block = recall.block(RecallContext(text="просто привет", kind="master", now=now))
|
||||
assert block is not None
|
||||
assert (
|
||||
"🗓 календарь (7 дней): событий нет, данные на 2026-09-01 14:00"
|
||||
in block.splitlines()
|
||||
)
|
||||
|
||||
|
||||
def test_calendar_failure_shows_up_in_the_envelope_instead_of_disappearing(
|
||||
tmp_path: Path,
|
||||
) -> None:
|
||||
recall = _vault(tmp_path, _calendar(None))
|
||||
now = datetime(2026, 9, 1, 12, 0, tzinfo=UTC)
|
||||
block = recall.block(RecallContext(text="просто привет", kind="master", now=now))
|
||||
assert block is not None
|
||||
assert "🗓 календарь: ОШИБКА личный: OSError: фид не ответил" in block.splitlines()
|
||||
# ветке справка календарь не носит, как и сроки досок
|
||||
branch = recall.block(RecallContext(text="просто привет", kind="branch", now=now))
|
||||
assert branch is None
|
||||
|
||||
|
||||
def test_without_configured_feeds_there_is_no_calendar_section(tmp_path: Path) -> None:
|
||||
recall = _vault(tmp_path)
|
||||
now = datetime(2026, 9, 1, 12, 0, tzinfo=UTC)
|
||||
block = recall.block(RecallContext(text="просто привет", kind="master", now=now))
|
||||
assert block is not None and "календарь" not in block
|
||||
@@ -1,592 +0,0 @@
|
||||
from datetime import UTC, datetime, timedelta
|
||||
from types import SimpleNamespace
|
||||
from typing import Any, cast
|
||||
|
||||
import pytest
|
||||
|
||||
from beaver_agent.hands.runs import (
|
||||
STREAK,
|
||||
Run,
|
||||
Runs,
|
||||
alarm_text,
|
||||
awake,
|
||||
clear_text,
|
||||
empty_text,
|
||||
first_line,
|
||||
look,
|
||||
mask,
|
||||
quiet_text,
|
||||
)
|
||||
|
||||
NOW = datetime(2026, 9, 22, 15, 42, tzinfo=UTC)
|
||||
BOOM = (
|
||||
"HubError: vibegram 530 bad_json: <!doctype html>\n"
|
||||
"Traceback (most recent call last):\n"
|
||||
' File "/app/src/beaver_gateway/jobs/scheduler.py", line 170, in _dispatch\n'
|
||||
"HubError: vibegram 530 bad_json"
|
||||
)
|
||||
|
||||
|
||||
def run(rid, job, status, *, ago, error=None):
|
||||
return Run(
|
||||
id=rid,
|
||||
job=job,
|
||||
status=status,
|
||||
started_at=NOW - timedelta(minutes=ago),
|
||||
error=error if error is not None or status != "failed" else BOOM,
|
||||
)
|
||||
|
||||
|
||||
def series(job, statuses, *, step=10, start=1000):
|
||||
"""Прогоны джоба от старых к новым: statuses[-1] - последний прогон."""
|
||||
ago = step * len(statuses)
|
||||
out = []
|
||||
for i, status in enumerate(statuses):
|
||||
out.append(run(start + i, job, status, ago=ago - step * i))
|
||||
return out
|
||||
|
||||
|
||||
def state(tmp_path, **kw):
|
||||
return Runs(path=tmp_path / "прогоны.json", **kw)
|
||||
|
||||
|
||||
def test_three_in_a_row_is_an_alarm(tmp_path):
|
||||
rows = series("вайбграм", ["done", "failed", "failed", "failed"])
|
||||
report = look(state(tmp_path), rows, now=NOW, me="прогоны")
|
||||
assert not report.empty and report.seen == 4
|
||||
(tail,) = report.alarms
|
||||
assert tail.job == "вайбграм" and tail.count == 3
|
||||
assert tail.since == NOW - timedelta(minutes=30)
|
||||
assert not tail.capped
|
||||
text = alarm_text(report)
|
||||
assert "джоб `вайбграм` лежит 30 минут, 3 прогона подряд" in text
|
||||
assert "с 22.09 15:12 UTC" in text
|
||||
# Первая строка ошибки, а не трейсбек
|
||||
assert "HubError: vibegram 530 bad_json" in text
|
||||
assert "Traceback" not in text and "scheduler.py" not in text
|
||||
|
||||
|
||||
def test_two_in_a_row_stays_quiet(tmp_path):
|
||||
rows = series("вайбграм", ["done", "failed", "failed"])
|
||||
report = look(state(tmp_path), rows, now=NOW, me="прогоны")
|
||||
assert not report.alarms and not report.clears and not report.empty
|
||||
# Одиночное падение - тем более молчание
|
||||
once = look(state(tmp_path), series("логи", ["failed"]), now=NOW, me="прогоны")
|
||||
assert not once.alarms
|
||||
|
||||
|
||||
def test_only_the_tail_counts(tmp_path):
|
||||
# Падало много, но последний прогон прошёл - джоб не лежит
|
||||
rows = series("логи", ["failed", "failed", "failed", "failed", "done"])
|
||||
assert not look(state(tmp_path), rows, now=NOW, me="прогоны").alarms
|
||||
|
||||
|
||||
def test_alarm_not_repeated_within_a_day(tmp_path):
|
||||
rows = series("вайбграм", ["done", "failed", "failed", "failed", "failed"])
|
||||
told = state(tmp_path, alerted={"вайбграм": NOW - timedelta(hours=5)})
|
||||
quiet = look(told, rows, now=NOW, me="прогоны")
|
||||
assert not quiet.alarms
|
||||
assert "уже говорили меньше суток назад" in quiet.note
|
||||
older = state(tmp_path, alerted={"вайбграм": NOW - timedelta(hours=25)})
|
||||
assert look(older, rows, now=NOW, me="прогоны").alarms
|
||||
|
||||
|
||||
def test_repair_clears_and_resets(tmp_path):
|
||||
rows = series("вайбграм", ["failed", "failed", "failed", "done"])
|
||||
told = state(tmp_path, alerted={"вайбграм": NOW - timedelta(hours=2)})
|
||||
report = look(told, rows, now=NOW, me="прогоны")
|
||||
assert not report.alarms
|
||||
(clear,) = report.clears
|
||||
assert clear.job == "вайбграм" and clear.count == 0 and clear.status == "done"
|
||||
assert "отбой: джоб `вайбграм` снова проходит (done)" in clear_text(report)
|
||||
# Сброс делает джоб; после него тот же вход снова может поднять тревогу
|
||||
del told.alerted["вайбграм"]
|
||||
again = look(told, series("вайбграм", ["failed"] * 3), now=NOW, me="прогоны")
|
||||
assert again.alarms
|
||||
|
||||
|
||||
def test_repair_is_told_once_not_every_run(tmp_path):
|
||||
rows = series("вайбграм", ["failed", "failed", "failed", "done"])
|
||||
clean = state(tmp_path)
|
||||
assert not look(clean, rows, now=NOW, me="прогоны").clears
|
||||
|
||||
|
||||
def test_flapping_job_is_a_clear_not_an_alarm(tmp_path):
|
||||
# После тревоги джоб моргает: хвост короче порога - он больше не лежит
|
||||
rows = series("вайбграм", ["done", "done", "failed", "failed"])
|
||||
told = state(tmp_path, alerted={"вайбграм": NOW - timedelta(hours=2)})
|
||||
report = look(told, rows, now=NOW, me="прогоны")
|
||||
(clear,) = report.clears
|
||||
assert clear.count == 2
|
||||
assert f"порог {STREAK}" in clear_text(report)
|
||||
|
||||
|
||||
def test_streak_running_past_the_window_says_at_least(tmp_path):
|
||||
rows = series("вайбграм", ["failed"] * 144, step=10)
|
||||
report = look(state(tmp_path), rows, now=NOW, me="прогоны")
|
||||
(tail,) = report.alarms
|
||||
assert tail.capped and tail.count == 144
|
||||
text = alarm_text(report)
|
||||
assert "лежит 24 часа и дольше, 144 прогона подряд" in text
|
||||
assert "это всё окно недели, серия началась раньше" in text
|
||||
|
||||
|
||||
def test_empty_window_is_its_own_alarm(tmp_path):
|
||||
report = look(state(tmp_path), [], now=NOW, me="прогоны")
|
||||
assert report.empty and not report.alarms and report.seen == 0
|
||||
assert "не отработал ни один джоб" in empty_text(report)
|
||||
assert "планировщике" in empty_text(report)
|
||||
# И повторяется не чаще раза в сутки
|
||||
told = state(tmp_path, empty_alerted=NOW - timedelta(hours=5))
|
||||
assert not look(told, [], now=NOW, me="прогоны").empty
|
||||
stale = state(tmp_path, empty_alerted=NOW - timedelta(hours=25))
|
||||
assert look(stale, [], now=NOW, me="прогоны").empty
|
||||
|
||||
|
||||
def test_own_runs_do_not_count_as_life_or_as_illness(tmp_path):
|
||||
mine = series("прогоны", ["failed", "failed", "failed", "done"])
|
||||
report = look(state(tmp_path), mine, now=NOW, me="прогоны")
|
||||
# Свои прогоны в окне есть, чужих нет: это всё равно пустое окно
|
||||
assert report.empty and not report.alarms and report.mine == 4
|
||||
assert "их 4" in empty_text(report)
|
||||
|
||||
|
||||
def test_forgotten_job_leaves_the_state_silently(tmp_path):
|
||||
rows = series("логи", ["done", "done"])
|
||||
told = state(
|
||||
tmp_path,
|
||||
alerted={
|
||||
"исчезнувший": NOW - timedelta(days=8),
|
||||
"недавний": NOW - timedelta(hours=3),
|
||||
},
|
||||
)
|
||||
report = look(told, rows, now=NOW, me="прогоны")
|
||||
assert not report.clears # починки мы не видели, «отбой» врать не о чем
|
||||
assert "исчезнувший" not in told.alerted
|
||||
assert "недавний" in told.alerted
|
||||
|
||||
|
||||
def test_several_broken_jobs_come_in_one_alarm(tmp_path):
|
||||
rows = [
|
||||
*series("вайбграм", ["failed"] * 4, start=100),
|
||||
*series("логи", ["failed"] * 3, start=200),
|
||||
*series("досуг", ["done"], start=300),
|
||||
]
|
||||
report = look(state(tmp_path), rows, now=NOW, me="прогоны")
|
||||
assert len(report.alarms) == 2
|
||||
assert report.alarms[0].job == "вайбграм" # длиннее серия - выше в тексте
|
||||
assert alarm_text(report).count("\n") == 1
|
||||
|
||||
|
||||
def test_first_line_masks_secrets_and_cuts_the_tail():
|
||||
assert first_line(None) == "без текста ошибки"
|
||||
assert first_line("") == "без текста ошибки"
|
||||
# Токен в строке ошибки не уезжает человеку
|
||||
assert "s3cr3tvalue" not in first_line("RuntimeError: MSOS_MCP=s3cr3tvalue died")
|
||||
assert "MSOS_MCP=<…>" in first_line("RuntimeError: MSOS_MCP=s3cr3tvalue died")
|
||||
assert "hunter2" not in first_line("ошибка: password=hunter2")
|
||||
assert "abc123" not in first_line("GET https://hub/api?t=abc123 -> 500")
|
||||
assert "https://hub/api?<…>" in first_line("GET https://hub/api?t=abc123 -> 500")
|
||||
assert "Bearer abcdefghij" not in first_line("Authorization: Bearer abcdefghij")
|
||||
# Длинная строка режется
|
||||
long = first_line("E: " + "x" * 500)
|
||||
assert len(long) == 160 and long.endswith("…")
|
||||
# Имя без запаха секрета остаётся читаемым
|
||||
assert mask("status=530 job=вайбграм") == "status=530 job=вайбграм"
|
||||
|
||||
|
||||
def test_state_survives_a_round_trip(tmp_path):
|
||||
saved = state(
|
||||
tmp_path,
|
||||
alerted={"вайбграм": NOW, "логи": NOW - timedelta(hours=3)},
|
||||
empty_alerted=NOW,
|
||||
)
|
||||
saved.save()
|
||||
back = Runs.load(saved.path)
|
||||
assert back.alerted["вайбграм"] == NOW
|
||||
assert back.alerted["логи"] == NOW - timedelta(hours=3)
|
||||
assert back.empty_alerted == NOW
|
||||
assert Runs.load(tmp_path / "нет.json").alerted == {}
|
||||
(tmp_path / "мусор.json").write_text("не json", encoding="utf-8")
|
||||
assert Runs.load(tmp_path / "мусор.json").empty_alerted is None
|
||||
|
||||
|
||||
class FakeRun:
|
||||
def __init__(self, database=None, *, name="прогоны", jobs=()):
|
||||
self.job = SimpleNamespace(name=name, cron="27 * * * *")
|
||||
self.conversations = SimpleNamespace(db=database)
|
||||
self.scheduler = SimpleNamespace(
|
||||
jobs=[self.job, *(SimpleNamespace(name=n, cron=c) for n, c in jobs)], tz=UTC
|
||||
)
|
||||
self.spawned = []
|
||||
|
||||
async def spawn_job(self, *, agent, text, title=None):
|
||||
self.spawned.append((agent, title, text))
|
||||
return None
|
||||
|
||||
|
||||
async def make_db(tmp_path, rows):
|
||||
from beaver_gateway.storage.db import Database
|
||||
from beaver_gateway.storage.models import JobRunRecord
|
||||
|
||||
database = Database(f"sqlite+aiosqlite:///{tmp_path / 'journal.db'}")
|
||||
await database.create_all()
|
||||
async with database.session() as session:
|
||||
for row in rows:
|
||||
session.add(row)
|
||||
await session.commit()
|
||||
return database
|
||||
|
||||
|
||||
def record(job, status, *, ago, error=None):
|
||||
from beaver_gateway.storage.models import JobRunRecord
|
||||
|
||||
started = (datetime.now(UTC) - timedelta(minutes=ago)).replace(tzinfo=None)
|
||||
return JobRunRecord(
|
||||
job=job,
|
||||
trigger="cron",
|
||||
started_at=started,
|
||||
finished_at=started,
|
||||
status=status,
|
||||
error=error if error is not None or status != "failed" else BOOM,
|
||||
)
|
||||
|
||||
|
||||
async def test_job_reads_the_real_journal_and_spawns(tmp_path, monkeypatch):
|
||||
from beaver_agent.jobs import runs as job
|
||||
|
||||
monkeypatch.setattr(job, "STATE_FILE", tmp_path / "прогоны.json")
|
||||
database = await make_db(
|
||||
tmp_path,
|
||||
[
|
||||
record("вайбграм", "failed", ago=30),
|
||||
record("вайбграм", "failed", ago=20),
|
||||
record("вайбграм", "failed", ago=10),
|
||||
record("досуг", "done", ago=5),
|
||||
record("прогоны", "done", ago=3),
|
||||
# Одно падение - не серия, сколько бы окно ни было
|
||||
record("логи", "failed", ago=60 * 30),
|
||||
],
|
||||
)
|
||||
run_ = FakeRun(database)
|
||||
|
||||
await job.watch_runs(cast("Any", run_))
|
||||
|
||||
assert len(run_.spawned) == 1
|
||||
agent, title, text = run_.spawned[0]
|
||||
assert agent == "beaver-triage" and title == "прогоны"
|
||||
assert "джоб `вайбграм` лежит" in text and "3 прогона подряд" in text
|
||||
assert "логи" not in text # одно падение
|
||||
assert "прогоны" not in text.split("\n")[1] # сам себя не считает
|
||||
# Тревога записана - следующий прогон в те же сутки молчит
|
||||
assert Runs.load(tmp_path / "прогоны.json").alerted["вайбграм"] is not None
|
||||
await job.watch_runs(cast("Any", run_))
|
||||
assert len(run_.spawned) == 1
|
||||
await database.dispose()
|
||||
|
||||
|
||||
async def test_job_says_otboy_when_the_job_recovers(tmp_path, monkeypatch):
|
||||
from beaver_agent.jobs import runs as job
|
||||
|
||||
monkeypatch.setattr(job, "STATE_FILE", tmp_path / "прогоны.json")
|
||||
Runs(
|
||||
path=tmp_path / "прогоны.json",
|
||||
alerted={"вайбграм": datetime.now(UTC) - timedelta(hours=2)},
|
||||
).save()
|
||||
database = await make_db(
|
||||
tmp_path,
|
||||
[
|
||||
record("вайбграм", "failed", ago=30),
|
||||
record("вайбграм", "failed", ago=20),
|
||||
record("вайбграм", "done", ago=10),
|
||||
],
|
||||
)
|
||||
run_ = FakeRun(database)
|
||||
|
||||
await job.watch_runs(cast("Any", run_))
|
||||
|
||||
assert len(run_.spawned) == 1
|
||||
_, _, text = run_.spawned[0]
|
||||
assert "отбой: джоб `вайбграм` снова проходит" in text
|
||||
assert 'urgency="normal"' in text # отбой не будит
|
||||
assert Runs.load(tmp_path / "прогоны.json").alerted == {}
|
||||
# Сброшено - второй «отбой» не уходит
|
||||
await job.watch_runs(cast("Any", run_))
|
||||
assert len(run_.spawned) == 1
|
||||
await database.dispose()
|
||||
|
||||
|
||||
async def test_job_alarms_on_an_empty_journal(tmp_path, monkeypatch):
|
||||
from beaver_agent.jobs import runs as job
|
||||
|
||||
monkeypatch.setattr(job, "STATE_FILE", tmp_path / "прогоны.json")
|
||||
database = await make_db(tmp_path, [record("прогоны", "done", ago=5)])
|
||||
run_ = FakeRun(database)
|
||||
|
||||
await job.watch_runs(cast("Any", run_))
|
||||
|
||||
assert len(run_.spawned) == 1
|
||||
_, _, text = run_.spawned[0]
|
||||
assert "нет ни одной записи" in text and "не отработал ни один джоб" in text
|
||||
assert Runs.load(tmp_path / "прогоны.json").empty_alerted is not None
|
||||
await database.dispose()
|
||||
|
||||
|
||||
async def test_unreadable_journal_is_not_a_reading(tmp_path, monkeypatch):
|
||||
from beaver_agent.jobs import runs as job
|
||||
|
||||
class Dead:
|
||||
def session(self):
|
||||
msg = "база не отвечает"
|
||||
raise RuntimeError(msg)
|
||||
|
||||
monkeypatch.setattr(job, "STATE_FILE", tmp_path / "прогоны.json")
|
||||
run_ = FakeRun(Dead())
|
||||
|
||||
await job.watch_runs(cast("Any", run_))
|
||||
|
||||
assert not run_.spawned
|
||||
assert not (tmp_path / "прогоны.json").exists()
|
||||
|
||||
|
||||
@pytest.mark.parametrize("name", ["прогоны", "иначе-названный"])
|
||||
async def test_the_watcher_never_reports_itself(tmp_path, monkeypatch, name):
|
||||
from beaver_agent.jobs import runs as job
|
||||
|
||||
monkeypatch.setattr(job, "STATE_FILE", tmp_path / "прогоны.json")
|
||||
database = await make_db(
|
||||
tmp_path,
|
||||
[
|
||||
record(name, "failed", ago=30),
|
||||
record(name, "failed", ago=20),
|
||||
record(name, "failed", ago=10),
|
||||
record("досуг", "done", ago=5),
|
||||
],
|
||||
)
|
||||
run_ = FakeRun(database, name=name)
|
||||
|
||||
await job.watch_runs(cast("Any", run_))
|
||||
|
||||
assert not run_.spawned
|
||||
await database.dispose()
|
||||
|
||||
|
||||
# --- Окно неделя: суточные джобы тоже набирают серию ---------------------------
|
||||
|
||||
|
||||
def test_daily_job_failing_three_days_in_a_row_is_an_alarm(tmp_path):
|
||||
day = 24 * 60
|
||||
rows = [
|
||||
run(1, "закрытие", "done", ago=4 * day - 60),
|
||||
run(2, "закрытие", "failed", ago=3 * day - 60),
|
||||
run(3, "закрытие", "failed", ago=2 * day - 60),
|
||||
run(4, "закрытие", "failed", ago=day - 60),
|
||||
]
|
||||
report = look(state(tmp_path), rows, now=NOW, me="прогоны")
|
||||
(tail,) = report.alarms
|
||||
assert tail.job == "закрытие" and tail.count == 3 and not tail.capped
|
||||
assert "джоб `закрытие` лежит 2 суток, 3 прогона подряд" in alarm_text(report)
|
||||
|
||||
|
||||
async def test_job_reads_a_week_back(tmp_path, monkeypatch):
|
||||
from beaver_agent.jobs import runs as job
|
||||
|
||||
monkeypatch.setattr(job, "STATE_FILE", tmp_path / "прогоны.json")
|
||||
day = 24 * 60
|
||||
database = await make_db(
|
||||
tmp_path,
|
||||
[
|
||||
record("голосовой", "failed", ago=3 * day - 30),
|
||||
record("голосовой", "failed", ago=2 * day - 30),
|
||||
record("голосовой", "failed", ago=day - 30),
|
||||
# Старше недели - в окно не попадает
|
||||
record("память", "failed", ago=9 * day),
|
||||
],
|
||||
)
|
||||
run_ = FakeRun(database)
|
||||
|
||||
await job.watch_runs(cast("Any", run_))
|
||||
|
||||
(spawned,) = run_.spawned
|
||||
assert "джоб `голосовой` лежит" in spawned[2]
|
||||
assert "память" not in spawned[2]
|
||||
await database.dispose()
|
||||
|
||||
|
||||
# --- Давность: джоб перестал запускаться ---------------------------------------
|
||||
|
||||
CRONS = {"прогоны": "27 * * * *", "закрытие": "20 4 * * *", "вайбграм": "*/10 * * * *"}
|
||||
|
||||
|
||||
def hourly_me(hours=72):
|
||||
"""Непрерывная цепочка своих прогонов: планировщик жив всё это время."""
|
||||
return [
|
||||
run(5000 + i, "прогоны", "done", ago=60 * (hours - i) - 15)
|
||||
for i in range(hours)
|
||||
]
|
||||
|
||||
|
||||
def alive(ago=5):
|
||||
return run(9000, "вайбграм", "done", ago=ago)
|
||||
|
||||
|
||||
def silent(tmp_path, *, closing_ago_h, mine=None, boot=None, **kw):
|
||||
last = run(1, "закрытие", "done", ago=closing_ago_h * 60)
|
||||
return look(
|
||||
kw.pop("runs", None) or state(tmp_path),
|
||||
[alive(), *(hourly_me() if mine is None else mine)],
|
||||
now=NOW,
|
||||
me="прогоны",
|
||||
crons=kw.pop("crons", CRONS),
|
||||
latest=kw.pop("latest", {"закрытие": last, "вайбграм": alive()}),
|
||||
tz=UTC,
|
||||
boot=boot,
|
||||
)
|
||||
|
||||
|
||||
def test_job_silent_longer_than_two_periods_is_its_own_alarm(tmp_path):
|
||||
report = silent(tmp_path, closing_ago_h=50)
|
||||
(quiet,) = report.quiet
|
||||
assert quiet.job == "закрытие" and quiet.period == timedelta(hours=24)
|
||||
assert not report.alarms # это не «лежит»
|
||||
text = quiet_text(report)
|
||||
assert "джоб `закрытие` не запускался 2 суток при периоде 24 часа" in text
|
||||
assert "лежит" not in text
|
||||
|
||||
|
||||
def test_one_missed_fire_is_not_silence(tmp_path):
|
||||
# 40 часов: пропущено одно срабатывание, не два
|
||||
assert not silent(tmp_path, closing_ago_h=40).quiet
|
||||
|
||||
|
||||
def test_silence_is_told_once_a_day_and_cleared_by_a_run(tmp_path):
|
||||
told = state(tmp_path, quiet={"закрытие": NOW - timedelta(hours=5)})
|
||||
held = silent(tmp_path, closing_ago_h=50, runs=told)
|
||||
assert not held.quiet
|
||||
assert "о молчании уже говорили меньше суток назад: закрытие" in held.note
|
||||
older = state(tmp_path, quiet={"закрытие": NOW - timedelta(hours=25)})
|
||||
assert silent(tmp_path, closing_ago_h=50, runs=older).quiet
|
||||
# Запуск появился после тревоги - «отбой», а не молчание
|
||||
back = silent(tmp_path, closing_ago_h=1, runs=told)
|
||||
(resumed,) = back.resumed
|
||||
assert resumed.job == "закрытие" and not back.clears
|
||||
assert "отбой: джоб `закрытие` снова запускается (done)" in clear_text(back)
|
||||
|
||||
|
||||
def test_downtime_of_the_scheduler_is_not_a_missed_fire(tmp_path):
|
||||
# Гейтвей только что поднялся: после старта срабатывания ещё не было
|
||||
fresh = silent(tmp_path, closing_ago_h=50, boot=NOW - timedelta(minutes=30))
|
||||
assert not fresh.quiet
|
||||
# Сторож сам не бегал сутки (бюджет зажат, некритичное откладывается):
|
||||
# пропуски за это время - общий простой, а не молчание одного джоба
|
||||
gap = [run(1, "прогоны", "done", ago=60 * 30)]
|
||||
assert not silent(tmp_path, closing_ago_h=50, mine=gap).quiet
|
||||
assert awake(gap, now=NOW, step=timedelta(hours=2), boot=None) == NOW
|
||||
|
||||
|
||||
def test_short_period_job_uses_the_watchers_resolution(tmp_path):
|
||||
latest = {"закрытие": run(1, "закрытие", "done", ago=60)}
|
||||
# Вайбграм раз в 10 минут, молчит 70 минут: сторож часовой, и такой
|
||||
# пропуск неотличим от его же слепоты между прогонами
|
||||
latest["вайбграм"] = run(2, "вайбграм", "done", ago=70)
|
||||
assert not silent(tmp_path, closing_ago_h=1, latest=latest).quiet
|
||||
latest["вайбграм"] = run(2, "вайбграм", "done", ago=150)
|
||||
(quiet,) = silent(tmp_path, closing_ago_h=1, latest=latest).quiet
|
||||
assert quiet.job == "вайбграм"
|
||||
assert "не запускался 2 часа при периоде 10 минут" in quiet_text(
|
||||
silent(tmp_path, closing_ago_h=1, latest=latest)
|
||||
)
|
||||
|
||||
|
||||
def test_job_without_cron_is_not_checked(tmp_path):
|
||||
# deploy - вебхук: крона у него нет, в `crons` он не попадает вовсе
|
||||
latest = {
|
||||
"deploy": run(1, "deploy", "done", ago=60 * 24 * 30),
|
||||
"закрытие": run(2, "закрытие", "done", ago=60),
|
||||
}
|
||||
report = silent(tmp_path, closing_ago_h=1, latest=latest)
|
||||
assert not report.quiet and "deploy" not in report.note
|
||||
|
||||
|
||||
def test_job_never_seen_in_the_journal_waits_silently(tmp_path):
|
||||
report = silent(tmp_path, closing_ago_h=0, latest={"вайбграм": alive()})
|
||||
assert not report.quiet and not report.resumed
|
||||
assert "ещё ни разу не запускались: закрытие" in report.note
|
||||
|
||||
|
||||
def test_irregular_schedule_is_skipped_and_named(tmp_path):
|
||||
crons = {**CRONS, "куратор": "0 2,8,12,16,20 * * *"}
|
||||
report = silent(tmp_path, closing_ago_h=1, crons=crons, latest={})
|
||||
assert report.unguarded == ("куратор",)
|
||||
assert "давностью не охраняются" in report.note and "куратор" in report.note
|
||||
assert not report.quiet
|
||||
|
||||
|
||||
def test_the_watcher_does_not_measure_its_own_silence(tmp_path):
|
||||
latest = {
|
||||
"прогоны": run(1, "прогоны", "done", ago=60 * 24 * 5),
|
||||
"закрытие": run(2, "закрытие", "done", ago=60),
|
||||
}
|
||||
report = silent(tmp_path, closing_ago_h=1, latest=latest)
|
||||
assert not report.quiet
|
||||
|
||||
|
||||
def test_job_removed_from_the_schedule_leaves_silence_state(tmp_path):
|
||||
told = state(tmp_path, quiet={"старый": NOW - timedelta(hours=3)})
|
||||
report = silent(tmp_path, closing_ago_h=1, runs=told)
|
||||
assert not report.resumed and "старый" not in told.quiet
|
||||
assert "сняты с давности (нет в расписании): старый" in report.note
|
||||
|
||||
|
||||
def test_real_schedule_names_only_the_curator_unguarded(tmp_path):
|
||||
from beaver_agent.jobs import jobs
|
||||
|
||||
crons = {job.name: job.cron for job in jobs if job.cron}
|
||||
report = silent(tmp_path, closing_ago_h=1, crons=crons, latest={})
|
||||
assert report.unguarded == ("куратор",)
|
||||
# Вебхуки в расписание давности не попадают
|
||||
assert {"deploy", "komodo", "t3code"}.isdisjoint(crons)
|
||||
|
||||
|
||||
async def test_job_alarms_on_a_silent_job_and_logs_the_unguarded(
|
||||
tmp_path, monkeypatch, caplog
|
||||
):
|
||||
from beaver_agent.jobs import runs as job
|
||||
|
||||
monkeypatch.setattr(job, "STATE_FILE", tmp_path / "прогоны.json")
|
||||
monkeypatch.setattr(job, "BOOT", datetime.now(UTC) - timedelta(days=10))
|
||||
database = await make_db(
|
||||
tmp_path,
|
||||
[
|
||||
record("закрытие", "done", ago=60 * 50),
|
||||
*(record("прогоны", "done", ago=60 * h - 15) for h in range(1, 73)),
|
||||
record("вайбграм", "done", ago=5),
|
||||
record("deploy", "done", ago=60 * 24 * 20),
|
||||
],
|
||||
)
|
||||
run_ = FakeRun(
|
||||
database,
|
||||
jobs=[
|
||||
("закрытие", "20 4 * * *"),
|
||||
("вайбграм", "*/10 * * * *"),
|
||||
("куратор", "0 2,8,12,16,20 * * *"),
|
||||
("deploy", None),
|
||||
("новый", "0 3 * * *"),
|
||||
],
|
||||
)
|
||||
|
||||
with caplog.at_level("INFO", logger=job.__name__):
|
||||
await job.watch_runs(cast("Any", run_))
|
||||
|
||||
(spawned,) = run_.spawned
|
||||
text = spawned[2]
|
||||
assert "ПЕРЕСТАЛИ ЗАПУСКАТЬСЯ" in text
|
||||
assert "джоб `закрытие` не запускался 2 суток при периоде 24 часа" in text
|
||||
assert "deploy" not in text and "новый" not in text
|
||||
assert "давностью не охраняются" in caplog.text and "куратор" in caplog.text
|
||||
assert "ещё ни разу не запускались: новый" in caplog.text
|
||||
assert "закрытие" in Runs.load(tmp_path / "прогоны.json").quiet
|
||||
# В те же сутки не повторяется
|
||||
await job.watch_runs(cast("Any", run_))
|
||||
assert len(run_.spawned) == 1
|
||||
await database.dispose()
|
||||
@@ -1,33 +0,0 @@
|
||||
from typing import Any
|
||||
|
||||
from beaver_agent.jobs.t3code import t3code_event
|
||||
|
||||
|
||||
class FakeRun:
|
||||
def __init__(self, payload: dict[str, Any]) -> None:
|
||||
self.payload = payload
|
||||
self.injects: list[tuple[str | None, str, str, str]] = []
|
||||
|
||||
async def inject_into(
|
||||
self, public_id: str | None, text: str, *, urgency: str, origin: str
|
||||
) -> bool:
|
||||
self.injects.append((public_id, text, urgency, origin))
|
||||
return True
|
||||
|
||||
|
||||
async def test_the_event_goes_to_the_conversation_that_dispatched() -> None:
|
||||
run = FakeRun(
|
||||
{
|
||||
"event": "completed",
|
||||
"thread_id": "t1",
|
||||
"title": "lint",
|
||||
"machine": "mac",
|
||||
"project": "beaver",
|
||||
"origin": "conv-7",
|
||||
"text": "done",
|
||||
}
|
||||
)
|
||||
await t3code_event(run) # ty: ignore[invalid-argument-type]
|
||||
[(target, text, urgency, origin)] = run.injects
|
||||
assert (target, urgency, origin) == ("conv-7", "urgent", "t3code")
|
||||
assert "завершён" in text and "done" in text
|
||||
@@ -1,201 +0,0 @@
|
||||
from urllib.parse import parse_qsl, urlsplit
|
||||
|
||||
import pytest
|
||||
from beaver_gateway.mcp.types import McpServer
|
||||
from beaver_gateway.mcp.wrap import build_python_tool_server
|
||||
from fastmcp import Client
|
||||
from fastmcp.exceptions import ToolError
|
||||
|
||||
from beaver_agent.hands.vibegram import PAGE, PAGES, Vibegram, _cards, _event, _work
|
||||
|
||||
|
||||
def test_events_render_and_unknown_kinds_are_skipped():
|
||||
msg = _event(
|
||||
{
|
||||
"id": 61,
|
||||
"nick": "claude-neighbour",
|
||||
"kind": "message",
|
||||
"payload": {"body": "@beaver-test привет"},
|
||||
"createdAt": "2026-08-30T10:00:00.000Z",
|
||||
}
|
||||
)
|
||||
assert (
|
||||
msg is not None
|
||||
and msg.line() == "[08-30 10:00] claude-neighbour: @beaver-test привет"
|
||||
)
|
||||
assert _event({"id": 1, "kind": "tree", "payload": {}}) is None
|
||||
|
||||
|
||||
def test_mentioned_and_cards():
|
||||
v = Vibegram(hub="http://127.0.0.1:9", token="t", nick="beaver-test")
|
||||
ev = _event(
|
||||
{
|
||||
"id": 2,
|
||||
"nick": "x",
|
||||
"kind": "message",
|
||||
"payload": {"body": "эй @Beaver-Test"},
|
||||
}
|
||||
)
|
||||
assert ev is not None and v.mentioned([ev])
|
||||
text = _cards(
|
||||
[
|
||||
{
|
||||
"nick": "beaver-test",
|
||||
"status": "online",
|
||||
"skills": [],
|
||||
"focus": {"holding": ["a.md"]},
|
||||
}
|
||||
],
|
||||
"beaver-test",
|
||||
)
|
||||
assert "(это ты)" in text and "держит: a.md" in text
|
||||
assert "плана в комнате пока нет" in _work(
|
||||
{"free": [], "taken": [], "busy": [], "cards": [], "planRevision": 0}, "me"
|
||||
)
|
||||
|
||||
|
||||
async def test_tool_schema_lists_actions_and_needs_text_for_send():
|
||||
tool = Vibegram(hub="http://127.0.0.1:9", token="t", nick="beaver-test")
|
||||
server = build_python_tool_server(
|
||||
McpServer.python_tool(name="vibegram", tools=[tool.vibegram])
|
||||
)
|
||||
async with Client(server) as client:
|
||||
(spec,) = await client.list_tools()
|
||||
assert {"read", "send", "who", "claim", "release"} <= set(
|
||||
spec.inputSchema["properties"]["action"]["enum"]
|
||||
)
|
||||
with pytest.raises(ToolError, match="text"):
|
||||
await client.call_tool("vibegram", {"action": "send"})
|
||||
|
||||
|
||||
def _raw(eid, kind, body=None):
|
||||
return {
|
||||
"id": eid,
|
||||
"roomId": "r",
|
||||
"nick": "claude-kai",
|
||||
"kind": kind,
|
||||
"payload": {} if body is None else {"body": body},
|
||||
"createdAt": "2026-09-23T05:00:02.000Z",
|
||||
}
|
||||
|
||||
|
||||
def _hub(monkeypatch, events):
|
||||
calls = []
|
||||
|
||||
async def call(self, method, path, body):
|
||||
calls.append(path)
|
||||
if path == "/api/room":
|
||||
return {"room": {"id": "r", "name": "kai-rem-watch", "viewToken": "v 1"}}
|
||||
query = dict(parse_qsl(urlsplit(path).query))
|
||||
assert query["view"] == "v 1" # ключ комнаты уезжает экранированным
|
||||
after = int(query.get("after", 0))
|
||||
return {"events": [e for e in events if e["id"] > after][:PAGE]}
|
||||
|
||||
monkeypatch.setattr(Vibegram, "_call", call)
|
||||
return calls, Vibegram(hub="http://hub", token="t", nick="beaver-test")
|
||||
|
||||
|
||||
async def test_window_pages_forward_to_the_end_and_drops_joins(monkeypatch):
|
||||
# 520 событий комнаты - три страницы по 200; join/leave в окно не идут
|
||||
events = [
|
||||
_raw(i, "message" if i % 4 else "agent_leave", f"строка {i}")
|
||||
for i in range(1, 521)
|
||||
]
|
||||
calls, room = _hub(monkeypatch, events)
|
||||
|
||||
window = await room.window(25)
|
||||
|
||||
assert window.full
|
||||
assert len(window.events) == 25
|
||||
assert window.events[-1].text.endswith("строка 519")
|
||||
assert all("вошёл" not in e.text and "вышел" not in e.text for e in window.events)
|
||||
assert calls.count("/api/room") == 1
|
||||
assert sum(p.startswith("/api/state") for p in calls) == 3
|
||||
assert "view=v%201" in calls[1]
|
||||
assert not any("pending" in p for p in calls) # курсор сторожу не окно
|
||||
|
||||
|
||||
async def test_window_that_ran_out_of_pages_says_it_is_not_full(monkeypatch):
|
||||
events = [_raw(i, "message", f"строка {i}") for i in range(1, 521)]
|
||||
_, room = _hub(monkeypatch, events)
|
||||
|
||||
assert not (await room.window(25, pages=2)).full
|
||||
assert (await room.window(25, pages=3)).full
|
||||
|
||||
|
||||
async def test_window_of_an_empty_room_is_full_and_empty(monkeypatch):
|
||||
_, room = _hub(monkeypatch, [])
|
||||
window = await room.window(25)
|
||||
assert window.full and window.events == []
|
||||
|
||||
|
||||
async def test_read_since_walks_history_without_touching_the_cursor(monkeypatch):
|
||||
events = [
|
||||
_raw(i, "message" if i % 4 else "agent_join", f"строка {i}")
|
||||
for i in range(1, 12)
|
||||
]
|
||||
calls, room = _hub(monkeypatch, events)
|
||||
|
||||
out = await room.vibegram("read", since=8)
|
||||
|
||||
assert out.splitlines() == [
|
||||
"#9 [09-23 05:00] claude-kai: строка 9",
|
||||
"#10 [09-23 05:00] claude-kai: строка 10",
|
||||
"#11 [09-23 05:00] claude-kai: строка 11",
|
||||
]
|
||||
assert not any("pending" in p for p in calls)
|
||||
|
||||
|
||||
async def test_read_last_shows_only_the_tail(monkeypatch):
|
||||
events = [_raw(i, "message", f"строка {i}") for i in range(1, 12)]
|
||||
_, room = _hub(monkeypatch, events)
|
||||
|
||||
out = await room.vibegram("read", last=2)
|
||||
|
||||
assert out.splitlines() == [
|
||||
"#10 [09-23 05:00] claude-kai: строка 10",
|
||||
"#11 [09-23 05:00] claude-kai: строка 11",
|
||||
]
|
||||
with pytest.raises(ValueError, match="last"):
|
||||
await room.vibegram("read", last=0)
|
||||
|
||||
|
||||
async def test_read_since_on_a_silent_room_says_history_is_read_out(monkeypatch):
|
||||
_, room = _hub(monkeypatch, [_raw(3, "message", "строка 3")])
|
||||
|
||||
assert await room.vibegram("read", since=3) == (
|
||||
"после #3 сообщений нет (история дочитана)"
|
||||
)
|
||||
|
||||
|
||||
async def test_read_since_admits_an_unfinished_window(monkeypatch):
|
||||
events = [_raw(i, "message", f"строка {i}") for i in range(1, PAGES * PAGE + 2)]
|
||||
_, room = _hub(monkeypatch, events)
|
||||
|
||||
out = await room.vibegram("read", since=0)
|
||||
|
||||
assert out.splitlines()[0] == "окно неполное: до конца истории не дочитали"
|
||||
|
||||
|
||||
async def test_plain_read_keeps_the_cursor_and_numbers_the_lines(monkeypatch):
|
||||
seen = []
|
||||
|
||||
async def call(self, method, path, body):
|
||||
seen.append(path)
|
||||
return {"events": [_raw(7, "message", "привет")]}
|
||||
|
||||
monkeypatch.setattr(Vibegram, "_call", call)
|
||||
room = Vibegram(hub="http://hub", token="t", nick="beaver-test")
|
||||
|
||||
assert await room.vibegram("read") == "#7 [09-23 05:00] claude-kai: привет"
|
||||
assert seen == ["/api/pending?limit=50"]
|
||||
|
||||
|
||||
async def test_tool_schema_exposes_since_and_last():
|
||||
tool = Vibegram(hub="http://127.0.0.1:9", token="t", nick="beaver-test")
|
||||
server = build_python_tool_server(
|
||||
McpServer.python_tool(name="vibegram", tools=[tool.vibegram])
|
||||
)
|
||||
async with Client(server) as client:
|
||||
(spec,) = await client.list_tools()
|
||||
assert {"since", "last"} <= set(spec.inputSchema["properties"])
|
||||
@@ -1,308 +0,0 @@
|
||||
import asyncio
|
||||
import json
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import UTC, datetime
|
||||
from typing import Any, cast
|
||||
|
||||
import httpx
|
||||
import pytest
|
||||
from beaver_gateway.app import AgentRegistry, McpRegistry
|
||||
from beaver_gateway.agents.claude import ClaudeAgent, ClaudeOptions
|
||||
from beaver_gateway.conversations.envelope import RecallContext
|
||||
from beaver_gateway.events.stream import (
|
||||
build_content_block_stop,
|
||||
build_message_delta,
|
||||
build_message_start,
|
||||
build_message_stop,
|
||||
build_text_block_start,
|
||||
build_text_delta,
|
||||
)
|
||||
from beaver_gateway.conversations.texts import UserSaid
|
||||
from beaver_gateway.frontends.base import GatewayRuntime
|
||||
from beaver_gateway.security.auth import TokenStore, scopes_with
|
||||
|
||||
from beaver_agent.memory.recall import Recall, ReplyLog
|
||||
from beaver_agent.voice import AGENT, KEY, TITLE, VoiceFrontend, rotate
|
||||
from beaver_agent.voice.texts import ROTATED
|
||||
|
||||
VOICE = {"Authorization": "Bearer voice-key"}
|
||||
OPS = {"Authorization": "Bearer ops-key"}
|
||||
ASK = {
|
||||
"room": "andreii",
|
||||
"device": "esp32-1",
|
||||
"request_id": "3fd0d6ed-a81b-489c-a1d2-3b97ba84892b",
|
||||
"content": "ало клод как дела",
|
||||
}
|
||||
PLAIN = {**ASK, "stream": False}
|
||||
"""То же, но одним JSON: без поля фронтенд стримит."""
|
||||
|
||||
|
||||
@dataclass
|
||||
class Conv:
|
||||
external_id: str = "conv-1"
|
||||
agent_name: str = AGENT
|
||||
kind: str = "branch"
|
||||
title: str = TITLE
|
||||
status: str = "open"
|
||||
last_user_activity_at: datetime | None = None
|
||||
flags: dict[str, Any] = field(default_factory=dict)
|
||||
|
||||
|
||||
@dataclass
|
||||
class Binding:
|
||||
frontend: str
|
||||
external_id: str
|
||||
visible: bool = True
|
||||
|
||||
|
||||
class FakeConversations:
|
||||
"""Ровно те методы сервиса, которыми пользуется голосовое окно."""
|
||||
|
||||
def __init__(self, bound: Conv | None = None) -> None:
|
||||
self.conv = bound
|
||||
self.bindings_of: dict[str, list[Binding]] = {}
|
||||
self.said: list[tuple[str, str]] = []
|
||||
self.prompts: list[str] = []
|
||||
self.bound: list[tuple[str, str, str]] = []
|
||||
self.closed: list[str] = []
|
||||
self.spawned: list[dict[str, Any]] = []
|
||||
self.reply = "живу, слушаю"
|
||||
self.spawn_hook = None
|
||||
|
||||
async def find_bound(self, *, frontend: str, external_id: str) -> Conv | None:
|
||||
if self.conv is None or frontend != "voice" or external_id != KEY:
|
||||
return None
|
||||
return self.conv
|
||||
|
||||
async def spawn(self, **kwargs: Any) -> Conv:
|
||||
self.spawned.append(kwargs)
|
||||
conv = Conv(external_id=f"conv-{len(self.spawned) + 1}")
|
||||
self.conv = conv
|
||||
binding = kwargs.get("binding")
|
||||
if binding:
|
||||
self.bindings_of[conv.external_id] = [Binding(*binding)]
|
||||
return conv
|
||||
|
||||
async def bind(self, conv: Conv, *, frontend: str, external_id: str) -> None:
|
||||
self.bound.append((conv.external_id, frontend, external_id))
|
||||
|
||||
async def bindings(self, conv: Conv) -> list[Binding]:
|
||||
return self.bindings_of.get(conv.external_id, [])
|
||||
|
||||
async def close(self, conv: Conv) -> None:
|
||||
conv.status = "closed"
|
||||
self.closed.append(conv.external_id)
|
||||
|
||||
async def say(self, conv: Conv, text: str) -> None:
|
||||
self.said.append((conv.external_id, text))
|
||||
|
||||
async def pending_seed(self, conv: Conv) -> str | None:
|
||||
return conv.flags.pop("seed", None)
|
||||
|
||||
async def run_text_turn(self, conv: Conv, prompt: str, **_: Any) -> tuple[str, Any]:
|
||||
self.prompts.append(prompt)
|
||||
return self.reply, None
|
||||
|
||||
async def turn(self, conv: Conv, *, messages: list[Any], **_: Any) -> Any:
|
||||
self.prompts.append(messages[0]["content"])
|
||||
yield build_message_start(message_id="m", model="haiku")
|
||||
yield build_text_block_start(0)
|
||||
for chunk in ("живу, ", "слушаю"):
|
||||
yield build_text_delta(0, chunk)
|
||||
yield build_content_block_stop(0)
|
||||
yield build_message_delta(stop_reason="end_turn")
|
||||
yield build_message_stop()
|
||||
|
||||
|
||||
class Bus:
|
||||
def __init__(self) -> None:
|
||||
self.events: list[dict[str, Any]] = []
|
||||
|
||||
def publish(self, type_: str, **data: Any) -> dict[str, Any]:
|
||||
event = {"type": type_, **data}
|
||||
self.events.append(event)
|
||||
return event
|
||||
|
||||
|
||||
def stand(conversations: FakeConversations) -> tuple[VoiceFrontend, GatewayRuntime]:
|
||||
agent = ClaudeAgent(
|
||||
name=AGENT,
|
||||
model="claude-haiku-4-5-20251001",
|
||||
cwd=".",
|
||||
system_prompt="голос",
|
||||
kinds=("branch",),
|
||||
options=ClaudeOptions(tools=()),
|
||||
)
|
||||
frontend = VoiceFrontend(agent=AGENT)
|
||||
runtime = GatewayRuntime(
|
||||
agents=AgentRegistry([agent]),
|
||||
mcps=McpRegistry([]),
|
||||
backends={},
|
||||
token_store=TokenStore(
|
||||
bootstrap={"voice": "voice-key", "ops": "ops-key"},
|
||||
bootstrap_scopes={"voice": "voice", "ops": "api"},
|
||||
),
|
||||
db=cast("Any", None),
|
||||
frontends=(frontend,),
|
||||
conversations=conversations,
|
||||
bus=Bus(),
|
||||
scopes=scopes_with(["voice"]),
|
||||
)
|
||||
frontend.configure(runtime)
|
||||
return frontend, runtime
|
||||
|
||||
|
||||
def client(frontend: VoiceFrontend) -> httpx.AsyncClient:
|
||||
return httpx.AsyncClient(
|
||||
transport=httpx.ASGITransport(app=cast("Any", frontend.app())),
|
||||
base_url="http://t",
|
||||
)
|
||||
|
||||
|
||||
async def test_the_payload_is_answered_and_its_fields_come_back() -> None:
|
||||
conversations = FakeConversations()
|
||||
frontend, _ = stand(conversations)
|
||||
async with client(frontend) as http:
|
||||
response = await http.post("/", json=PLAIN, headers=VOICE)
|
||||
assert response.status_code == 200
|
||||
assert response.json() == {
|
||||
"request_id": ASK["request_id"],
|
||||
"room": "andreii",
|
||||
"device": "esp32-1",
|
||||
"reply": "живу, слушаю",
|
||||
"conversation": "conv-2",
|
||||
}
|
||||
assert conversations.prompts == ["[andreii · esp32-1] ало клод как дела"]
|
||||
|
||||
|
||||
async def test_the_first_ask_opens_the_branch_and_the_next_one_keeps_it() -> None:
|
||||
conversations = FakeConversations()
|
||||
frontend, _ = stand(conversations)
|
||||
async with client(frontend) as http:
|
||||
first = (await http.post("/", json=PLAIN, headers=VOICE)).json()
|
||||
again = (
|
||||
await http.post("/", json={**PLAIN, "content": "а время?"}, headers=VOICE)
|
||||
).json()
|
||||
assert first["conversation"] == again["conversation"]
|
||||
assert len(conversations.spawned) == 1
|
||||
spawn = conversations.spawned[0]
|
||||
assert spawn["kind"] == "branch"
|
||||
assert spawn["agent"] == AGENT
|
||||
assert spawn["title"] == TITLE
|
||||
assert spawn["binding"] is None
|
||||
assert conversations.bound == [(first["conversation"], "voice", KEY)]
|
||||
|
||||
|
||||
async def test_the_question_lands_in_the_branch_first() -> None:
|
||||
conversations = FakeConversations()
|
||||
frontend, _ = stand(conversations)
|
||||
async with client(frontend) as http:
|
||||
await http.post("/", json=PLAIN, headers=VOICE)
|
||||
assert conversations.said == [("conv-2", "🎤 andreii · esp32-1\nало клод как дела")]
|
||||
|
||||
|
||||
async def test_two_rooms_at_once_open_one_branch() -> None:
|
||||
conversations = FakeConversations()
|
||||
frontend, _ = stand(conversations)
|
||||
async with client(frontend) as http:
|
||||
await asyncio.gather(
|
||||
http.post("/", json=PLAIN, headers=VOICE),
|
||||
http.post("/", json={**PLAIN, "room": "кухня"}, headers=VOICE),
|
||||
)
|
||||
assert len(conversations.spawned) == 1
|
||||
|
||||
|
||||
async def test_only_a_voice_key_opens_the_route() -> None:
|
||||
frontend, _ = stand(FakeConversations())
|
||||
async with client(frontend) as http:
|
||||
assert (await http.post("/", json=ASK)).status_code == 401
|
||||
assert (await http.post("/", json=ASK, headers=OPS)).status_code == 403
|
||||
|
||||
|
||||
async def test_a_body_without_the_words_is_a_400() -> None:
|
||||
frontend, _ = stand(FakeConversations())
|
||||
async with client(frontend) as http:
|
||||
for missing in ("room", "device", "content"):
|
||||
body = {k: v for k, v in ASK.items() if k != missing}
|
||||
response = await http.post("/", json=body, headers=VOICE)
|
||||
assert response.status_code == 400
|
||||
assert missing in response.json()["error"]
|
||||
|
||||
|
||||
async def test_the_night_keeps_the_topic_and_starts_the_branch_over() -> None:
|
||||
old = Conv(last_user_activity_at=datetime.now(UTC))
|
||||
conversations = FakeConversations(bound=old)
|
||||
conversations.bindings_of["conv-1"] = [Binding("telegram", "42")]
|
||||
new = await rotate(cast("Any", conversations))
|
||||
assert new is not None
|
||||
assert conversations.spawned[0]["binding"] == ("telegram", "42")
|
||||
assert conversations.bound == [(new.external_id, "voice", KEY)]
|
||||
assert conversations.closed == ["conv-1"]
|
||||
assert conversations.said == [(new.external_id, ROTATED)]
|
||||
|
||||
|
||||
async def test_a_branch_nobody_spoke_in_is_left_alone() -> None:
|
||||
conversations = FakeConversations(bound=Conv())
|
||||
assert await rotate(cast("Any", conversations)) is None
|
||||
assert conversations.spawned == []
|
||||
|
||||
|
||||
def test_the_voice_agent_gets_no_recall_and_no_reply_log(tmp_path) -> None:
|
||||
recall = Recall(
|
||||
vault=tmp_path,
|
||||
people_dir=tmp_path / "люди",
|
||||
notes_dir=tmp_path / "записки",
|
||||
diary_dir=tmp_path / "дни",
|
||||
boards_dir=tmp_path / "доски",
|
||||
mute=frozenset({AGENT}),
|
||||
)
|
||||
now = datetime.now(UTC)
|
||||
assert (
|
||||
recall.block(RecallContext(text="Прохор", kind="branch", now=now, agent=AGENT))
|
||||
is None
|
||||
)
|
||||
log = ReplyLog(tmp_path / "реплики", mute=frozenset({AGENT}))
|
||||
log.write(
|
||||
UserSaid(
|
||||
conversation_id="c",
|
||||
kind="branch",
|
||||
title=TITLE,
|
||||
text="что там у Прохор",
|
||||
at=now,
|
||||
agent=AGENT,
|
||||
)
|
||||
)
|
||||
assert not (tmp_path / "реплики").exists()
|
||||
|
||||
|
||||
async def test_the_answer_streams_when_the_body_does_not_say_otherwise() -> None:
|
||||
conversations = FakeConversations()
|
||||
frontend, _ = stand(conversations)
|
||||
frames: list[tuple[str, dict[str, Any]]] = []
|
||||
async with (
|
||||
client(frontend) as http,
|
||||
http.stream("POST", "/", json=ASK, headers=VOICE) as sse,
|
||||
):
|
||||
assert sse.status_code == 200
|
||||
assert sse.headers["content-type"].startswith("text/event-stream")
|
||||
buffer = "".join([chunk async for chunk in sse.aiter_text()])
|
||||
for block in buffer.split("\n\n"):
|
||||
lines = [line for line in block.splitlines() if line]
|
||||
if len(lines) == 2 and lines[0].startswith("event: "):
|
||||
frames.append((lines[0][7:], json.loads(lines[1][6:])))
|
||||
assert [name for name, _ in frames] == ["delta", "delta", "done"]
|
||||
assert [f["text"] for _, f in frames[:2]] == ["живу, ", "слушаю"]
|
||||
assert frames[-1][1]["reply"] == "живу, слушаю"
|
||||
assert frames[-1][1]["request_id"] == ASK["request_id"]
|
||||
|
||||
|
||||
async def test_the_flag_is_read_as_a_word_not_as_a_truthy_string() -> None:
|
||||
frontend, _ = stand(FakeConversations())
|
||||
cases = ((True, True), ("true", True), (False, False), ("false", False), (0, False))
|
||||
async with client(frontend) as http:
|
||||
for value, streams in cases:
|
||||
response = await http.post(
|
||||
"/", json={**ASK, "stream": value}, headers=VOICE
|
||||
)
|
||||
kind = response.headers["content-type"]
|
||||
assert kind.startswith("text/event-stream") is streams, (value, kind)
|
||||
@@ -3,8 +3,8 @@ revision = 3
|
||||
requires-python = ">=3.13"
|
||||
resolution-markers = [
|
||||
"python_full_version >= '3.14' and extra != 'extra-12-beaver-agent-local' and extra == 'extra-12-beaver-agent-prod'",
|
||||
"python_full_version >= '3.14' and extra == 'extra-12-beaver-agent-local' and extra != 'extra-12-beaver-agent-prod'",
|
||||
"python_full_version < '3.14' and extra != 'extra-12-beaver-agent-local' and extra == 'extra-12-beaver-agent-prod'",
|
||||
"python_full_version >= '3.14' and extra == 'extra-12-beaver-agent-local' and extra != 'extra-12-beaver-agent-prod'",
|
||||
"python_full_version < '3.14' and extra == 'extra-12-beaver-agent-local' and extra != 'extra-12-beaver-agent-prod'",
|
||||
"extra != 'extra-12-beaver-agent-local' and extra != 'extra-12-beaver-agent-prod'",
|
||||
]
|
||||
@@ -25,32 +25,6 @@ wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/67/cd/0d76dfc5de72bde52f55f53e925c7d152d9c7906634ec1e0cbc7e8d4ad93/aiofile-3.11.1-py3-none-any.whl", hash = "sha256:ce77d14ac07f77bc2b757834a5c129321f3f705c474593deed5ab209079a52c9", size = 20446, upload-time = "2026-05-16T08:18:32.051Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "aiofiles"
|
||||
version = "25.1.0"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/41/c3/534eac40372d8ee36ef40df62ec129bee4fdb5ad9706e58a29be53b2c970/aiofiles-25.1.0.tar.gz", hash = "sha256:a8d728f0a29de45dc521f18f07297428d56992a742f0cd2701ba86e44d23d5b2", size = 46354, upload-time = "2025-10-09T20:51:04.358Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/bc/8a/340a1555ae33d7354dbca4faa54948d76d89a27ceef032c8c3bc661d003e/aiofiles-25.1.0-py3-none-any.whl", hash = "sha256:abe311e527c862958650f9438e859c1fa7568a141b22abcd015e120e86a85695", size = 14668, upload-time = "2025-10-09T20:51:03.174Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "aiogram"
|
||||
version = "3.31.0"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
dependencies = [
|
||||
{ name = "aiofiles" },
|
||||
{ name = "aiohttp" },
|
||||
{ name = "certifi" },
|
||||
{ name = "magic-filter" },
|
||||
{ name = "pydantic" },
|
||||
{ name = "typing-extensions" },
|
||||
]
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/ec/5f/b2ee094181bb578c0987eef92a51af1fc2caa2be3589da2e37543c0f2906/aiogram-3.31.0.tar.gz", hash = "sha256:f2c5064fe52d88898c86af62261c405440a014216e45dd99b2c6555a5602ce30", size = 2025095, upload-time = "2026-08-26T00:00:42.97Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/ab/dd/c1ea24eb687e564b6b64db3939b858bbcbd3f6998496508a168ce54c5770/aiogram-3.31.0-py3-none-any.whl", hash = "sha256:d889493c5917a867fc9da81fd6e6b3ae438e98bfe1b004fcdafe7400461a6c1b", size = 859100, upload-time = "2026-08-26T00:00:41.178Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "aiohappyeyeballs"
|
||||
version = "2.6.2"
|
||||
@@ -290,8 +264,6 @@ prod = [
|
||||
|
||||
[package.dev-dependencies]
|
||||
dev = [
|
||||
{ name = "pytest" },
|
||||
{ name = "pytest-asyncio" },
|
||||
{ name = "ruff" },
|
||||
{ name = "ty" },
|
||||
]
|
||||
@@ -306,8 +278,6 @@ provides-extras = ["local", "prod"]
|
||||
|
||||
[package.metadata.requires-dev]
|
||||
dev = [
|
||||
{ name = "pytest", specifier = ">=9.1.1" },
|
||||
{ name = "pytest-asyncio", specifier = ">=1.4.0" },
|
||||
{ name = "ruff", specifier = ">=0.15.13" },
|
||||
{ name = "ty", specifier = ">=0.0.37" },
|
||||
]
|
||||
@@ -357,20 +327,17 @@ resolution-markers = [
|
||||
]
|
||||
dependencies = [
|
||||
{ name = "aiofile" },
|
||||
{ name = "aiogram" },
|
||||
{ name = "aiohttp" },
|
||||
{ name = "aiosqlite" },
|
||||
{ name = "anthropic" },
|
||||
{ name = "anyio" },
|
||||
{ name = "argon2-cffi" },
|
||||
{ name = "claude-agent-sdk" },
|
||||
{ name = "croniter" },
|
||||
{ name = "cryptography" },
|
||||
{ name = "fastapi" },
|
||||
{ name = "fastmcp" },
|
||||
{ name = "greenlet" },
|
||||
{ name = "itsdangerous" },
|
||||
{ name = "pgqueuer" },
|
||||
{ name = "jinja2" },
|
||||
{ name = "psutil" },
|
||||
{ name = "psycopg", extra = ["binary"], marker = "extra == 'extra-12-beaver-agent-local'" },
|
||||
{ name = "pydantic" },
|
||||
@@ -379,26 +346,22 @@ dependencies = [
|
||||
{ name = "sqlmodel" },
|
||||
{ name = "uvicorn", extra = ["standard"], marker = "extra == 'extra-12-beaver-agent-local'" },
|
||||
{ name = "uvloop" },
|
||||
{ name = "watchfiles" },
|
||||
]
|
||||
|
||||
[package.metadata]
|
||||
requires-dist = [
|
||||
{ name = "aiofile", specifier = ">=3.11.1" },
|
||||
{ name = "aiogram", specifier = ">=3.31.0" },
|
||||
{ name = "aiohttp", specifier = ">=3.13.5" },
|
||||
{ name = "aiosqlite", specifier = ">=0.22.1" },
|
||||
{ name = "anthropic", specifier = ">=0.103.0" },
|
||||
{ name = "anyio", specifier = ">=4.13.0" },
|
||||
{ name = "argon2-cffi", specifier = ">=25.1.0" },
|
||||
{ name = "claude-agent-sdk", specifier = ">=0.2.157" },
|
||||
{ name = "croniter", specifier = ">=6.2.4" },
|
||||
{ name = "cryptography", specifier = ">=48.0.0" },
|
||||
{ name = "claude-agent-sdk", specifier = ">=0.2.146" },
|
||||
{ name = "fastapi", specifier = ">=0.136.1" },
|
||||
{ name = "fastmcp", specifier = ">=3.3.1" },
|
||||
{ name = "greenlet", specifier = ">=3.5.0" },
|
||||
{ name = "itsdangerous", specifier = ">=2.2.0" },
|
||||
{ name = "pgqueuer", specifier = ">=1.3.2" },
|
||||
{ name = "jinja2", specifier = ">=3.1.6" },
|
||||
{ name = "psutil", specifier = ">=7.2.2" },
|
||||
{ name = "psycopg", extras = ["binary"], specifier = ">=3.3.4" },
|
||||
{ name = "pydantic", specifier = ">=2.13.4" },
|
||||
@@ -409,7 +372,6 @@ requires-dist = [
|
||||
{ name = "sqlmodel", specifier = ">=0.0.38" },
|
||||
{ name = "uvicorn", extras = ["standard"], specifier = ">=0.47.0" },
|
||||
{ name = "uvloop", specifier = ">=0.22.1" },
|
||||
{ name = "watchfiles", specifier = ">=1.2.0" },
|
||||
]
|
||||
provides-extras = ["local", "prod"]
|
||||
|
||||
@@ -504,7 +466,7 @@ wheels = [
|
||||
|
||||
[[package]]
|
||||
name = "claude-agent-sdk"
|
||||
version = "0.2.157"
|
||||
version = "0.2.146"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
dependencies = [
|
||||
{ name = "anyio" },
|
||||
@@ -512,12 +474,13 @@ dependencies = [
|
||||
{ name = "mcp" },
|
||||
{ name = "sniffio" },
|
||||
]
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/b4/e3/444df1691c864a8349067686719b43e714fc43d3853fb1b2ebc2097e2a6e/claude_agent_sdk-0.2.157.tar.gz", hash = "sha256:4ce6f41bc965fcb4a9d11bd7a3cac266975c75b632f3d74a26f55f0fffb3160a", size = 346579, upload-time = "2026-09-18T18:21:10.306Z" }
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/46/08/a79f73aad2156f4518ae6e0fffbcdb403cd5347d62b994b005a0c9bb12fb/claude_agent_sdk-0.2.146.tar.gz", hash = "sha256:9e402548466018421cfd0725a7601e14d9e3e879276a6a4a877c5a2ff6633546", size = 344704, upload-time = "2026-08-27T22:25:46.687Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/ec/e8/3e9cc23eb5a5a01a0e2ee931a17db2785f95407525d50366af06a4a5469c/claude_agent_sdk-0.2.157-py3-none-macosx_11_0_arm64.whl", hash = "sha256:dd6a2c7aa1901e43b827411d62f2327aed82f53ed8ca6b076eaa5be4a1fc681f", size = 92744001, upload-time = "2026-09-18T18:21:15.969Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/49/eb/e5095703a8efbe504ec468cab039543caabfc0ea3327c735a3d1b60e57ac/claude_agent_sdk-0.2.157-py3-none-macosx_11_0_x86_64.whl", hash = "sha256:ebf3f514c61db9be01bbf6d1acb0d993247340583b3559d2df75e3822f618bbb", size = 97352326, upload-time = "2026-09-18T18:21:21.007Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/d6/f4/64505beb3c757b863753d6556539554704ec9168cb96454dc6463b14df85/claude_agent_sdk-0.2.157-py3-none-manylinux_2_17_aarch64.whl", hash = "sha256:a58089e0c11364db2ec7a139e09b36a4fb9c95817a758bee7b28e0434f55c0b6", size = 102701030, upload-time = "2026-09-18T18:21:27.065Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/03/8f/2a7c121469fd16d1d6465bec180726c54f6e151b12e50835283b4285d1ce/claude_agent_sdk-0.2.157-py3-none-manylinux_2_17_x86_64.whl", hash = "sha256:bd126b2edee3a247b2c7c4cee1f5a3ea68ef748288ec0650db88dd3918e5471a", size = 102830653, upload-time = "2026-09-18T18:21:32.948Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/e4/e2/7618d7ffd3d4580d53d1147e7baba005c3bf4359d8bb8ab9beab62b5a0ec/claude_agent_sdk-0.2.146-py3-none-macosx_11_0_arm64.whl", hash = "sha256:7bcb91dd34c2e0e5b4f006648d457bbfba9aa1e44cf2e5d02abb441dcbbaff98", size = 84087716, upload-time = "2026-08-27T22:25:50.846Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/1f/e6/004b957547e32f6df4948c3a5a3c06974c6c19539c357ebe40a1a23941d3/claude_agent_sdk-0.2.146-py3-none-macosx_11_0_x86_64.whl", hash = "sha256:9285b3dd900376b045a06d2d6f5e19bfd96a3f6cb88d21166bb840aff14ee505", size = 88567306, upload-time = "2026-08-27T22:25:54.876Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/37/fa/1c1cb847ff8a92f6ec9a0176a984ec1902cf6eab6c027fd45059d211a96d/claude_agent_sdk-0.2.146-py3-none-manylinux_2_17_aarch64.whl", hash = "sha256:ad536806e6c6fc1972ae3950b1bb171f1494e6f47002c24dbc68f19af1c34997", size = 94195787, upload-time = "2026-08-27T22:25:59.367Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/60/f9/48aa74e5a85ebe11b916a99b053cc64f47bea8409ec2b9ada5b5a1169a7a/claude_agent_sdk-0.2.146-py3-none-manylinux_2_17_x86_64.whl", hash = "sha256:1f2bae0759f3962be2714c786c1a6961824c5ce3d4b7f44f0828191bd44ccebe", size = 94385743, upload-time = "2026-08-27T22:26:03.218Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/0d/d4/ff986dc35330146cba60a1bb6ee3f521cdec25ccc0306ef359b9d0cb59c4/claude_agent_sdk-0.2.146-py3-none-win_amd64.whl", hash = "sha256:dc2c4773dc02492b52c74f957a059ecbc0aec7063bd1a16c039b78613194b3cf", size = 97049829, upload-time = "2026-08-27T22:26:08.701Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -549,18 +512,6 @@ wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "croniter"
|
||||
version = "6.2.4"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
dependencies = [
|
||||
{ name = "python-dateutil" },
|
||||
]
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/37/57/2e2a65aee2a70483cb28e2b7e15a072d00a523207593b44400d4717bb100/croniter-6.2.4.tar.gz", hash = "sha256:fc124f751b1b04805c2a04b061898b436b45ab2320b045e1e052ea895de65189", size = 166267, upload-time = "2026-07-10T09:52:59.955Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/cd/ba/d678e5bd329646ca51d3c92addbc77804e86d21f4b6b6a027218e6abb010/croniter-6.2.4-py3-none-any.whl", hash = "sha256:8ef3d544107a5c05a150a2d78f8bf5a8eb9c5c4d93405a736b824109574e3f4d", size = 46677, upload-time = "2026-07-10T09:52:58.425Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cryptography"
|
||||
version = "48.0.0"
|
||||
@@ -976,15 +927,6 @@ wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/d2/23/408243171aa9aaba178d3e2559159c24c1171a641aa83b67bdd3394ead8e/idna-3.15-py3-none-any.whl", hash = "sha256:048adeaf8c2d788c40fee287673ccaa74c24ffd8dcf09ffa555a2fbb59f10ac8", size = 72340, upload-time = "2026-05-12T22:45:55.733Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "iniconfig"
|
||||
version = "2.3.0"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itsdangerous"
|
||||
version = "2.2.0"
|
||||
@@ -1182,15 +1124,6 @@ wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/81/db/e655086b7f3a705df045bf0933bdd9c2f79bb3c97bfef1384598bb79a217/keyring-25.7.0-py3-none-any.whl", hash = "sha256:be4a0b195f149690c166e850609a477c532ddbfbaed96a404d4e43f8d5e2689f", size = 39160, upload-time = "2025-11-16T16:26:08.402Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "magic-filter"
|
||||
version = "1.0.12"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/e6/08/da7c2cc7398cc0376e8da599d6330a437c01d3eace2f2365f300e0f3f758/magic_filter-1.0.12.tar.gz", hash = "sha256:4751d0b579a5045d1dc250625c4c508c18c3def5ea6afaf3957cb4530d03f7f9", size = 11071, upload-time = "2023-10-01T12:33:19.006Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/cc/75/f620449f0056eff0ec7c1b1e088f71068eb4e47a46eb54f6c065c6ad7675/magic_filter-1.0.12-py3-none-any.whl", hash = "sha256:e5929e544f310c2b1f154318db8c5cdf544dd658efa998172acd2e4ba0f6c6a6", size = 11335, upload-time = "2023-10-01T12:33:17.711Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "markdown-it-py"
|
||||
version = "4.2.0"
|
||||
@@ -1421,24 +1354,6 @@ wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/a2/e8/6d75ffd9784bce2e93d1ae4415649427e39a53bb172d4672b2b59c6f0a7b/pathable-0.6.0-py3-none-any.whl", hash = "sha256:82c4ca6c98c502ad12e0d4e9779b6210afee93c38990988c8c5d1b49bdcdf566", size = 18983, upload-time = "2026-05-19T18:15:10.728Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "pgqueuer"
|
||||
version = "1.3.2"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
dependencies = [
|
||||
{ name = "anyio" },
|
||||
{ name = "croniter" },
|
||||
{ name = "pydantic" },
|
||||
{ name = "pydantic-settings" },
|
||||
{ name = "tabulate" },
|
||||
{ name = "typer" },
|
||||
{ name = "uvloop", marker = "sys_platform != 'win32'" },
|
||||
]
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/33/10/6af18eede8a31c6d016564fd815d0cf1aaa69b8e584108a604b88f1ea56c/pgqueuer-1.3.2.tar.gz", hash = "sha256:11f4c67d9dfc343c02d8bb2e362733a0d44272f6c7e846630fe198f688fa3ed1", size = 505605, upload-time = "2026-07-27T16:58:00.864Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/82/16/1e501ee36fb8e6bdde6a3a4dd9b10d1b45c548e02f9c1f11e9ffc62ee922/pgqueuer-1.3.2-py3-none-any.whl", hash = "sha256:0823fcb089bb3ffd0580518e91b53888c9be742b42e706f9860b6a533f32bc44", size = 146747, upload-time = "2026-07-27T16:57:59.153Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "platformdirs"
|
||||
version = "4.9.6"
|
||||
@@ -1448,15 +1363,6 @@ wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/75/a6/a0a304dc33b49145b21f4808d763822111e67d1c3a32b524a1baf947b6e1/platformdirs-4.9.6-py3-none-any.whl", hash = "sha256:e61adb1d5e5cb3441b4b7710bea7e4c12250ca49439228cc1021c00dcfac0917", size = 21348, upload-time = "2026-04-09T00:04:09.463Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "pluggy"
|
||||
version = "1.6.0"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "propcache"
|
||||
version = "0.5.2"
|
||||
@@ -1773,46 +1679,6 @@ wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/df/80/fc9d01d5ed37ba4c42ca2b55b4339ae6e200b456be3a1aaddf4a9fa99b8c/pyperclip-1.11.0-py3-none-any.whl", hash = "sha256:299403e9ff44581cb9ba2ffeed69c7aa96a008622ad0c46cb575ca75b5b84273", size = 11063, upload-time = "2025-09-26T14:40:36.069Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "pytest"
|
||||
version = "9.1.1"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
dependencies = [
|
||||
{ name = "colorama", marker = "sys_platform == 'win32' or (extra == 'extra-12-beaver-agent-local' and extra == 'extra-12-beaver-agent-prod')" },
|
||||
{ name = "iniconfig" },
|
||||
{ name = "packaging" },
|
||||
{ name = "pluggy" },
|
||||
{ name = "pygments" },
|
||||
]
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "pytest-asyncio"
|
||||
version = "1.4.0"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
dependencies = [
|
||||
{ name = "pytest" },
|
||||
]
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/43/7c/d36d04db312ecf4298932ef77e6e4a9e8ad017906e24e34f0b0c361a2473/pytest_asyncio-1.4.0.tar.gz", hash = "sha256:c6c0d2259945122819f171a32ecea2c349ead889ee28176caaf492143424be42", size = 58514, upload-time = "2026-05-26T09:56:04.083Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/03/e2/08a497ef684b88559c9cc5f4ad53a37e7b99e727094a86d6ea32536d5d3c/pytest_asyncio-1.4.0-py3-none-any.whl", hash = "sha256:933ca923a23075a87fb7070c0ec272a6848489824d887c85c812670932835aa1", size = 16930, upload-time = "2026-05-26T09:56:02.576Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "python-dateutil"
|
||||
version = "2.9.0.post0"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
dependencies = [
|
||||
{ name = "six" },
|
||||
]
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "python-dotenv"
|
||||
version = "1.2.2"
|
||||
@@ -2057,24 +1923,6 @@ wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/b7/46/f5af3402b579fd5e11573ce652019a67074317e18c1935cc0b4ba9b35552/secretstorage-3.5.0-py3-none-any.whl", hash = "sha256:0ce65888c0725fcb2c5bc0fdb8e5438eece02c523557ea40ce0703c266248137", size = 15554, upload-time = "2025-11-23T19:02:51.545Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "shellingham"
|
||||
version = "1.5.4"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "six"
|
||||
version = "1.17.0"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "sniffio"
|
||||
version = "1.3.1"
|
||||
@@ -2162,15 +2010,6 @@ wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/0b/c9/584bc9651441b4ba60cc4d557d8a547b5aff901af35bda3a4ee30c819b82/starlette-1.0.0-py3-none-any.whl", hash = "sha256:d3ec55e0bb321692d275455ddfd3df75fff145d009685eb40dc91fc66b03d38b", size = 72651, upload-time = "2026-03-22T18:29:45.111Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tabulate"
|
||||
version = "0.10.0"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/46/58/8c37dea7bbf769b20d58e7ace7e5edfe65b849442b00ffcdd56be88697c6/tabulate-0.10.0.tar.gz", hash = "sha256:e2cfde8f79420f6deeffdeda9aaec3b6bc5abce947655d17ac662b126e48a60d", size = 91754, upload-time = "2026-03-04T18:55:34.402Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/99/55/db07de81b5c630da5cbf5c7df646580ca26dfaefa593667fc6f2fe016d2e/tabulate-0.10.0-py3-none-any.whl", hash = "sha256:f0b0622e567335c8fabaaa659f1b33bcb6ddfe2e496071b743aa113f8774f2d3", size = 39814, upload-time = "2026-03-04T18:55:31.284Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ty"
|
||||
version = "0.0.75"
|
||||
@@ -2196,21 +2035,6 @@ wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/39/73/4542f829107468b5de4231af67f29927c093bfad11f3c1e5b2c08fb1206b/ty-0.0.75-py3-none-win_arm64.whl", hash = "sha256:541c9af5b7a0ad23d15ec315a7da81150833c359f48124ed3789ff25eacd6f42", size = 12711024, upload-time = "2026-08-26T20:23:38.159Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "typer"
|
||||
version = "0.27.2"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
dependencies = [
|
||||
{ name = "annotated-doc" },
|
||||
{ name = "colorama", marker = "sys_platform == 'win32'" },
|
||||
{ name = "rich" },
|
||||
{ name = "shellingham" },
|
||||
]
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/16/f7/57713ba479fd405eb76de31404b2c744c289e336b2d999511ebf51e496f7/typer-0.27.2.tar.gz", hash = "sha256:269b7eb9d3c202ca84b4bc9618cb04ebb43d3d4d1e567e4c768607232c05f945", size = 204045, upload-time = "2026-08-28T10:26:55.046Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/dc/bf/205d0004930ede8f542fb58f601526fccf4ae7626075ca1e6c4de5d3d652/typer-0.27.2-py3-none-any.whl", hash = "sha256:b3a5fc4342d5fc8fda8fc3010b1cf117e9249aab7fae800c2eff62fd3842d97d", size = 123130, upload-time = "2026-08-28T10:26:53.752Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "typing-extensions"
|
||||
version = "4.15.0"
|
||||
|
||||
Reference in new issue
Block a user