diff --git a/.planning/ROADMAP.md b/.planning/ROADMAP.md index f90a331..1d5c220 100644 --- a/.planning/ROADMAP.md +++ b/.planning/ROADMAP.md @@ -4,14 +4,23 @@ ### Phase 1: Matrix QA & Polish -**Goal:** Проверить Matrix адаптер в ручном режиме, зафиксировать и устранить все найденные баги — до уровня "приемлемо работает" как у Telegram. +**Goal:** Переработать Matrix адаптер с DM-first на Space+rooms, убрать реакции в пользу !yes/!no, довести до уровня "приемлемо работает" как Telegram. -**Depends on:** Telegram QA complete ✓ +**Depends on:** Telegram QA complete + +**Plans:** 4 plans + +Plans: +- [ ] 01-01-PLAN.md — Space+rooms infrastructure (store helpers, handle_invite rewrite, room_router) +- [ ] 01-02-PLAN.md — Chat command handlers (!new, !archive, !rename) Space-aware +- [ ] 01-03-PLAN.md — Reaction removal + !yes/!no confirmation + settings dashboard +- [ ] 01-04-PLAN.md — Test suite (fix 4 broken + 12 new MAT-01..MAT-12) **Deliverables:** -- Ручной QA Matrix бота (invite flow, !new, !skills, !soul, !safety, room-per-chat) -- Все критические баги исправлены -- 96+ тестов зелёные +- Space+rooms architecture for Matrix adapter +- !yes/!no text-based confirmation (no reactions) +- Read-only !settings dashboard +- 96+ tests green --- diff --git a/.planning/phases/01-matrix-qa-polish/01-01-PLAN.md b/.planning/phases/01-matrix-qa-polish/01-01-PLAN.md new file mode 100644 index 0000000..ac40025 --- /dev/null +++ b/.planning/phases/01-matrix-qa-polish/01-01-PLAN.md @@ -0,0 +1,373 @@ +--- +phase: 01-matrix-qa-polish +plan: 01 +type: execute +wave: 1 +depends_on: [] +files_modified: + - adapter/matrix/store.py + - adapter/matrix/handlers/auth.py + - adapter/matrix/room_router.py +autonomous: true +requirements: [] + +must_haves: + truths: + - "Bot creates a Space named 'Lambda - {display_name}' on first invite" + - "Bot creates 'Chat 1' room inside that Space" + - "Bot invites user to both Space and chat room" + - "space_id is stored in user_meta for future lookups" + - "Repeated invite does not create a second Space (idempotent)" + - "chat_id uses next_chat_id, not hardcoded C1" + artifacts: + - path: "adapter/matrix/store.py" + provides: "pending_confirm helpers + PENDING_CONFIRM_PREFIX" + contains: "PENDING_CONFIRM_PREFIX" + - path: "adapter/matrix/handlers/auth.py" + provides: "Space+rooms invite flow" + contains: "space=True" + - path: "adapter/matrix/room_router.py" + provides: "space-aware resolve_chat_id" + key_links: + - from: "adapter/matrix/handlers/auth.py" + to: "adapter/matrix/store.py" + via: "set_user_meta with space_id" + pattern: "set_user_meta.*space_id" + - from: "adapter/matrix/handlers/auth.py" + to: "adapter/matrix/store.py" + via: "next_chat_id for dynamic C-number" + pattern: "next_chat_id" +--- + + +Rewrite the Matrix invite flow from DM-first to Space+rooms architecture, and add pending_confirm store helpers. + +Purpose: Per D-01/D-02, the bot must create a Space per user on first invite, with a "Chat 1" room inside it. The old DM join + hardcoded C1 flow must be fully replaced. Additionally, pending_confirm helpers are added to store.py now (used by Plan 03) to avoid file conflicts. + +Output: Working handle_invite that creates Space + chat room, stores space_id in user_meta, uses next_chat_id. Store has pending_confirm helpers. + + + +@$HOME/.claude/get-shit-done/workflows/execute-plan.md +@$HOME/.claude/get-shit-done/templates/summary.md + + + +@.planning/PROJECT.md +@.planning/ROADMAP.md +@.planning/STATE.md +@.planning/phases/01-matrix-qa-polish/01-CONTEXT.md +@.planning/phases/01-matrix-qa-polish/01-RESEARCH.md + +@adapter/matrix/store.py +@adapter/matrix/handlers/auth.py +@adapter/matrix/room_router.py +@core/protocol.py + + + + +```python +ROOM_META_PREFIX = "matrix_room:" +USER_META_PREFIX = "matrix_user:" +ROOM_STATE_PREFIX = "matrix_state:" +SKILLS_MSG_PREFIX = "matrix_skills_msg:" + +async def get_room_meta(store: StateStore, room_id: str) -> dict | None +async def set_room_meta(store: StateStore, room_id: str, meta: dict) -> None +async def get_user_meta(store: StateStore, matrix_user_id: str) -> dict | None +async def set_user_meta(store: StateStore, matrix_user_id: str, meta: dict) -> None +async def get_room_state(store: StateStore, room_id: str) -> str +async def set_room_state(store: StateStore, room_id: str, state: str) -> None +async def get_skills_message_id(store: StateStore, room_id: str) -> str | None +async def set_skills_message_id(store: StateStore, room_id: str, event_id: str) -> None +async def next_chat_id(store: StateStore, matrix_user_id: str) -> str +``` + + + +```python +@dataclass +class OutgoingMessage: + chat_id: str + text: str + parse_mode: str = "plain" + attachments: list[Attachment] = field(default_factory=list) + reply_to: str | None = None +``` + + + +```python +from nio.responses import RoomCreateError, RoomPutStateError, RoomInviteError +# RoomCreateError has .status_code, no .room_id +# RoomPutStateError has .status_code +``` + + + + + + + Task 1: Add pending_confirm helpers to store.py + adapter/matrix/store.py + adapter/matrix/store.py + +Add three new helper functions and one constant to `adapter/matrix/store.py`, AFTER the existing `next_chat_id` function. Keep ALL existing code unchanged. + +Add this constant after line 8 (after `SKILLS_MSG_PREFIX`): + +```python +PENDING_CONFIRM_PREFIX = "matrix_pending_confirm:" +``` + +Add these three functions at the end of the file: + +```python +async def get_pending_confirm(store: StateStore, room_id: str) -> dict | None: + return await store.get(f"{PENDING_CONFIRM_PREFIX}{room_id}") + + +async def set_pending_confirm(store: StateStore, room_id: str, meta: dict) -> None: + await store.set(f"{PENDING_CONFIRM_PREFIX}{room_id}", meta) + + +async def clear_pending_confirm(store: StateStore, room_id: str) -> None: + await store.delete(f"{PENDING_CONFIRM_PREFIX}{room_id}") +``` + +Note: `store.delete` is already available on `StateStore` (both `InMemoryStore` and `SQLiteStore` implement it). Verify by checking `core/store.py` — if `delete` is not present, use `store.set(key, None)` as equivalent. + +Per D-08: pending_confirm is keyed by room_id (not user_id+room_id) because in Space model each room belongs to one user. + + + cd /Users/a/MAI/sem2/lambda/surfaces-bot && python -c "from adapter.matrix.store import get_pending_confirm, set_pending_confirm, clear_pending_confirm, PENDING_CONFIRM_PREFIX; print('OK')" + + +- `adapter/matrix/store.py` contains the string `PENDING_CONFIRM_PREFIX = "matrix_pending_confirm:"` +- `adapter/matrix/store.py` contains function `async def get_pending_confirm(store: StateStore, room_id: str) -> dict | None:` +- `adapter/matrix/store.py` contains function `async def set_pending_confirm(store: StateStore, room_id: str, meta: dict) -> None:` +- `adapter/matrix/store.py` contains function `async def clear_pending_confirm(store: StateStore, room_id: str) -> None:` +- All existing functions (`get_room_meta`, `set_room_meta`, `get_user_meta`, `set_user_meta`, `get_room_state`, `set_room_state`, `get_skills_message_id`, `set_skills_message_id`, `next_chat_id`) still exist unchanged +- `pytest tests/adapter/matrix/test_store.py -x -q` passes (all existing store tests green) + + pending_confirm helpers importable and existing store tests pass + + + + Task 2: Rewrite handle_invite for Space+rooms (per D-01, D-02) + adapter/matrix/handlers/auth.py + adapter/matrix/handlers/auth.py, adapter/matrix/store.py, core/protocol.py + +Completely rewrite `adapter/matrix/handlers/auth.py`. The new `handle_invite` must: + +1. **Idempotency check on user_meta (not room_meta):** Check `get_user_meta(store, matrix_user_id)`. If it already has a `space_id`, return early (do nothing). This replaces the old `get_room_meta(store, room.room_id)` check. Per Pitfall 5 from RESEARCH.md. + +2. **Create Space:** Call `await client.room_create(name=f"Lambda -- {display_name}", space=True, visibility="private")`. Check `isinstance(resp, RoomCreateError)` — if error, log and return early. + +3. **Create first chat room:** Call `await client.room_create(name="Chat 1", visibility="private", is_direct=False)`. Check `isinstance(resp, RoomCreateError)`. + +4. **Add room to Space:** Call `await client.room_put_state(room_id=space_id, event_type="m.space.child", content={"via": [homeserver]}, state_key=chat_room_id)`. Extract `homeserver` as `matrix_user_id.split(":")[-1]`. + +5. **Invite user to both:** `await client.room_invite(space_id, matrix_user_id)` and `await client.room_invite(chat_room_id, matrix_user_id)`. + +6. **Use next_chat_id:** Call `chat_id = await next_chat_id(store, matrix_user_id)` to get "C1" (not hardcoded). Per D-05 and Pitfall 6 from RESEARCH.md. + +7. **Store user_meta:** `await set_user_meta(store, matrix_user_id, {"space_id": space_id, "next_chat_index": 2})`. Note: next_chat_id already incremented to 2, so store will already have next_chat_index=2 after the call. Just ensure space_id is stored in user_meta. + +8. **Store room_meta:** `await set_room_meta(store, chat_room_id, {"room_type": "chat", "chat_id": chat_id, "display_name": "Chat 1", "matrix_user_id": matrix_user_id, "space_id": space_id})`. + +9. **Auth confirm:** Keep `await auth_mgr.confirm(matrix_user_id)`. + +10. **Platform get_or_create_user:** Keep existing call. + +11. **Welcome message:** Send to the CHAT ROOM (not the invite room). Text: +``` +"Привет, {display_name}! Пиши -- я здесь.\n\nКоманды: !new . !chats . !rename . !archive . !skills . !soul . !safety . !settings" +``` + +12. **Also join the original invite room:** Keep `await client.join(room.room_id)` so the bot accepts the DM invite (otherwise nio may not process events from this user). Put this BEFORE Space creation. + +Complete replacement for `adapter/matrix/handlers/auth.py`: + +```python +from __future__ import annotations + +import structlog +from typing import Any + +from nio.responses import RoomCreateError + +from adapter.matrix.store import get_user_meta, set_user_meta, set_room_meta, next_chat_id + +logger = structlog.get_logger(__name__) + + +async def handle_invite(client: Any, room: Any, event: Any, platform, store, auth_mgr) -> None: + matrix_user_id = getattr(event, "sender", "") + display_name = getattr(room, "display_name", None) or matrix_user_id + + # Idempotency: if user already has a Space, skip + existing = await get_user_meta(store, matrix_user_id) + if existing and existing.get("space_id"): + return + + # Accept the invite room (so nio tracks this user) + await client.join(room.room_id) + + # Register user on platform + user = await platform.get_or_create_user( + external_id=matrix_user_id, + platform="matrix", + display_name=display_name, + ) + await auth_mgr.confirm(matrix_user_id) + + homeserver = matrix_user_id.split(":")[-1] + + # 1. Create Space + space_resp = await client.room_create( + name=f"Lambda \u2014 {display_name}", + space=True, + visibility="private", + ) + if isinstance(space_resp, RoomCreateError): + logger.error("space creation failed", user=matrix_user_id, error=getattr(space_resp, "status_code", None)) + return + space_id = space_resp.room_id + + # 2. Create first chat room + chat_resp = await client.room_create( + name="\u0427\u0430\u0442 1", + visibility="private", + is_direct=False, + ) + if isinstance(chat_resp, RoomCreateError): + logger.error("chat room creation failed", user=matrix_user_id, error=getattr(chat_resp, "status_code", None)) + return + chat_room_id = chat_resp.room_id + + # 3. Link chat room into Space + await client.room_put_state( + room_id=space_id, + event_type="m.space.child", + content={"via": [homeserver]}, + state_key=chat_room_id, + ) + + # 4. Invite user + await client.room_invite(space_id, matrix_user_id) + await client.room_invite(chat_room_id, matrix_user_id) + + # 5. Store metadata + chat_id = await next_chat_id(store, matrix_user_id) # Returns "C1", increments to 2 + + # Update user_meta to include space_id (next_chat_id already set next_chat_index) + user_meta = await get_user_meta(store, matrix_user_id) or {} + user_meta["space_id"] = space_id + await set_user_meta(store, matrix_user_id, user_meta) + + await set_room_meta(store, chat_room_id, { + "room_type": "chat", + "chat_id": chat_id, + "display_name": "\u0427\u0430\u0442 1", + "matrix_user_id": matrix_user_id, + "space_id": space_id, + }) + + # 6. Welcome message in chat room + welcome = ( + f"\u041f\u0440\u0438\u0432\u0435\u0442, {user.display_name or matrix_user_id}! \u041f\u0438\u0448\u0438 \u2014 \u044f \u0437\u0434\u0435\u0441\u044c.\n\n" + "\u041a\u043e\u043c\u0430\u043d\u0434\u044b: !new \u00b7 !chats \u00b7 !rename \u00b7 !archive \u00b7 !skills \u00b7 !soul \u00b7 !safety \u00b7 !settings" + ) + await client.room_send(chat_room_id, "m.room.message", {"msgtype": "m.text", "body": welcome}) +``` + +IMPORTANT: Use the actual Cyrillic characters in strings, not unicode escapes. The unicode escapes above are just for plan encoding safety. The actual file must have readable Russian text: "Чат 1", "Привет, ...", "Команды: ..." etc. + + + cd /Users/a/MAI/sem2/lambda/surfaces-bot && python -c "from adapter.matrix.handlers.auth import handle_invite; print('OK')" + + +- `adapter/matrix/handlers/auth.py` does NOT contain the string `"chat_id": "C1"` (hardcode removed) +- `adapter/matrix/handlers/auth.py` contains the string `space=True` +- `adapter/matrix/handlers/auth.py` contains the string `room_put_state` +- `adapter/matrix/handlers/auth.py` contains the string `next_chat_id` +- `adapter/matrix/handlers/auth.py` contains the string `get_user_meta` +- `adapter/matrix/handlers/auth.py` imports from `nio.responses` (specifically `RoomCreateError`) +- `adapter/matrix/handlers/auth.py` contains `room_invite` (invites user to Space and chat room) +- `adapter/matrix/handlers/auth.py` contains `m.space.child` string + + handle_invite creates Space + chat room, stores space_id, uses next_chat_id, is idempotent on user_meta + + + + Task 3: Update room_router.py for space-aware resolve + adapter/matrix/room_router.py + adapter/matrix/room_router.py, adapter/matrix/store.py + +The current `resolve_chat_id` in `adapter/matrix/room_router.py` auto-creates room_meta with a new chat_id if none exists. This is problematic in the Space model because rooms should only be created through `handle_invite` or `!new`. Update the fallback behavior: + +Replace the entire `adapter/matrix/room_router.py` with: + +```python +from __future__ import annotations + +import structlog + +from adapter.matrix.store import get_room_meta +from core.store import StateStore + +logger = structlog.get_logger(__name__) + + +async def resolve_chat_id(store: StateStore, room_id: str, matrix_user_id: str) -> str: + meta = await get_room_meta(store, room_id) + if meta and meta.get("chat_id"): + return meta["chat_id"] + + # Room not registered — this can happen if the bot receives a message + # in a room it didn't create (e.g., a DM). Return a fallback chat_id + # based on room_id to avoid crashing, but don't auto-register. + logger.warning("unregistered_room", room_id=room_id, user=matrix_user_id) + return f"unregistered:{room_id}" +``` + +Key changes: +- Remove `next_chat_id` and `set_room_meta` imports (no longer auto-creating) +- Remove auto-creation of room_meta for unknown rooms +- Return `f"unregistered:{room_id}"` as fallback so messages from unregistered rooms don't crash but are identifiable +- Add structlog warning for debugging + + + cd /Users/a/MAI/sem2/lambda/surfaces-bot && python -c "from adapter.matrix.room_router import resolve_chat_id; print('OK')" + + +- `adapter/matrix/room_router.py` does NOT contain `next_chat_id` +- `adapter/matrix/room_router.py` does NOT contain `set_room_meta` +- `adapter/matrix/room_router.py` contains `unregistered:{room_id}` or `f"unregistered:{room_id}"` +- `adapter/matrix/room_router.py` contains `get_room_meta` +- `adapter/matrix/room_router.py` contains `logger.warning` + + resolve_chat_id no longer auto-creates rooms, returns fallback for unregistered rooms + + + + + +After all 3 tasks: +- `python -c "from adapter.matrix.handlers.auth import handle_invite; from adapter.matrix.store import get_pending_confirm, set_pending_confirm, clear_pending_confirm; from adapter.matrix.room_router import resolve_chat_id; print('ALL IMPORTS OK')"` +- `pytest tests/adapter/matrix/test_store.py -x -q` passes (existing store tests still green) + + + +- handle_invite creates Space (space=True) + chat room + room_put_state link +- No hardcoded "C1" in auth.py +- pending_confirm helpers available in store.py +- room_router doesn't auto-create rooms +- Existing store tests pass + + + +After completion, create `.planning/phases/01-matrix-qa-polish/01-01-SUMMARY.md` + diff --git a/.planning/phases/01-matrix-qa-polish/01-02-PLAN.md b/.planning/phases/01-matrix-qa-polish/01-02-PLAN.md new file mode 100644 index 0000000..1f5e277 --- /dev/null +++ b/.planning/phases/01-matrix-qa-polish/01-02-PLAN.md @@ -0,0 +1,409 @@ +--- +phase: 01-matrix-qa-polish +plan: 02 +type: execute +wave: 1 +depends_on: [] +files_modified: + - adapter/matrix/handlers/chat.py +autonomous: true +requirements: [] + +must_haves: + truths: + - "!new creates a room and adds it to the user's Space via room_put_state" + - "!new without space_id returns an error message (not a crash)" + - "!archive removes room from Space via room_put_state with empty content" + - "!rename calls client.room_set_name if client available" + - "RoomCreateError is handled gracefully with user-facing message" + artifacts: + - path: "adapter/matrix/handlers/chat.py" + provides: "Space-aware chat commands" + contains: "room_put_state" + key_links: + - from: "adapter/matrix/handlers/chat.py" + to: "adapter/matrix/store.py" + via: "get_user_meta for space_id lookup" + pattern: "get_user_meta" + - from: "adapter/matrix/handlers/chat.py" + to: "client.room_put_state" + via: "m.space.child state event" + pattern: "m.space.child" +--- + + +Rewrite chat command handlers (!new, !archive, !rename) to work with Space+rooms architecture. + +Purpose: Per D-03/D-04, !new must create rooms inside the user's Space, !archive must remove rooms from Space (not delete). Currently !new creates standalone rooms without Space linkage, and !archive has no Space awareness. + +Output: make_handle_new_chat, handle_archive, handle_rename all Space-aware with proper error handling. + + + +@$HOME/.claude/get-shit-done/workflows/execute-plan.md +@$HOME/.claude/get-shit-done/templates/summary.md + + + +@.planning/PROJECT.md +@.planning/ROADMAP.md +@.planning/phases/01-matrix-qa-polish/01-CONTEXT.md +@.planning/phases/01-matrix-qa-polish/01-RESEARCH.md + +@adapter/matrix/handlers/chat.py +@adapter/matrix/store.py +@adapter/matrix/room_router.py +@core/protocol.py + + + + +```python +async def get_user_meta(store: StateStore, matrix_user_id: str) -> dict | None +async def set_user_meta(store: StateStore, matrix_user_id: str, meta: dict) -> None +async def get_room_meta(store: StateStore, room_id: str) -> dict | None +async def set_room_meta(store: StateStore, room_id: str, meta: dict) -> None +async def next_chat_id(store: StateStore, matrix_user_id: str) -> str +``` + + + +```python +def register_matrix_handlers(dispatcher: EventDispatcher, client=None, store=None) -> None: + dispatcher.register(IncomingCommand, "new", make_handle_new_chat(client, store)) + dispatcher.register(IncomingCommand, "archive", handle_archive) + dispatcher.register(IncomingCommand, "rename", handle_rename) +``` + +Note: `make_handle_new_chat(client, store)` is a closure factory. `handle_archive` and `handle_rename` are plain async functions — they do NOT receive `client` or `store` directly. To give archive/rename access to `client` and `store`, either: +(a) Convert them to closure factories like `make_handle_new_chat`, OR +(b) Pass client/store through the existing `register_matrix_handlers` pattern. + +Recommended: Convert `handle_archive` to `make_handle_archive(client, store)` and `handle_rename` to `make_handle_rename(client, store)` following the same pattern as `make_handle_new_chat`. Then update `adapter/matrix/handlers/__init__.py` registrations. + + + +```python +@dataclass +class IncomingCommand: + user_id: str + platform: str + chat_id: str + command: str + args: list[str] = field(default_factory=list) + +@dataclass +class OutgoingMessage: + chat_id: str + text: str +``` + + + +```python +from nio.responses import RoomCreateError, RoomPutStateError +``` + + + + + + + Task 1: Rewrite make_handle_new_chat for Space (per D-03) + adapter/matrix/handlers/chat.py + adapter/matrix/handlers/chat.py, adapter/matrix/store.py, adapter/matrix/handlers/__init__.py, core/protocol.py + +Rewrite `make_handle_new_chat` in `adapter/matrix/handlers/chat.py`. The function signature stays the same (closure factory receiving `client` and `store`), but the inner logic changes: + +```python +def make_handle_new_chat( + client: Any | None, + store: Any | None, +) -> Callable[..., Awaitable[list]]: + async def handle_new_chat( + event: IncomingCommand, auth_mgr, platform, chat_mgr, settings_mgr + ) -> list: + if client is None or store is None: + return await _fallback_new_chat(event, auth_mgr, platform, chat_mgr, settings_mgr) + + if not await auth_mgr.is_authenticated(event.user_id): + return [OutgoingMessage(chat_id=event.chat_id, text="Сначала примите приглашение бота.")] + + # Get user's space_id + user_meta = await get_user_meta(store, event.user_id) + space_id = (user_meta or {}).get("space_id") + if not space_id: + return [OutgoingMessage(chat_id=event.chat_id, text="Ошибка: Space не найден. Примите приглашение бота заново.")] + + name = " ".join(event.args).strip() if event.args else "" + chat_id = await next_chat_id(store, event.user_id) + room_name = name or f"Чат {chat_id}" + + # Create room + resp = await client.room_create(name=room_name, visibility="private", is_direct=False) + if isinstance(resp, RoomCreateError): + logger.error("room_create failed", user=event.user_id, error=getattr(resp, "status_code", None)) + return [OutgoingMessage(chat_id=event.chat_id, text="Не удалось создать комнату.")] + room_id = resp.room_id + + # Add room to Space + homeserver = event.user_id.split(":")[-1] + await client.room_put_state( + room_id=space_id, + event_type="m.space.child", + content={"via": [homeserver]}, + state_key=room_id, + ) + + # Invite user + await client.room_invite(room_id, event.user_id) + + # Store room metadata + await set_room_meta(store, room_id, { + "room_type": "chat", + "chat_id": chat_id, + "display_name": room_name, + "matrix_user_id": event.user_id, + "space_id": space_id, + }) + + # Register in core ChatManager + ctx = await chat_mgr.get_or_create( + user_id=event.user_id, + chat_id=chat_id, + platform=event.platform, + surface_ref=room_id, + name=room_name, + ) + return [ + OutgoingMessage( + chat_id=event.chat_id, + text=f"Создан чат: {ctx.display_name} ({ctx.chat_id})", + ) + ] + + return handle_new_chat +``` + +Add required imports at top of file: + +```python +import structlog +from nio.responses import RoomCreateError +from adapter.matrix.store import get_user_meta, set_room_meta, next_chat_id +``` + +Keep `_fallback_new_chat` as-is (it works without client). + +Also update `_fallback_new_chat` to use `next_chat_id` from store instead of counting chats: + +Replace the line `chat_id = f"C{len(chats) + 1}"` with a call to `next_chat_id` if store is available. Actually, `_fallback_new_chat` doesn't have store access, so keep it as-is — it's only used when client/store are None. + +Add `logger = structlog.get_logger(__name__)` after imports. + + + cd /Users/a/MAI/sem2/lambda/surfaces-bot && python -c "from adapter.matrix.handlers.chat import make_handle_new_chat; print('OK')" + + +- `adapter/matrix/handlers/chat.py` contains `get_user_meta` +- `adapter/matrix/handlers/chat.py` contains `room_put_state` +- `adapter/matrix/handlers/chat.py` contains `m.space.child` +- `adapter/matrix/handlers/chat.py` contains `RoomCreateError` +- `adapter/matrix/handlers/chat.py` contains `space_id` +- `adapter/matrix/handlers/chat.py` contains `next_chat_id` +- `adapter/matrix/handlers/chat.py` contains `room_invite` + + make_handle_new_chat creates rooms inside user's Space, handles errors gracefully + + + + Task 2: Convert handle_archive and handle_rename to Space-aware closures (per D-04) + adapter/matrix/handlers/chat.py, adapter/matrix/handlers/__init__.py + adapter/matrix/handlers/chat.py, adapter/matrix/handlers/__init__.py + +**Part A: Convert handle_archive to make_handle_archive(client, store)** + +Replace the current `handle_archive` function with a closure factory: + +```python +def make_handle_archive( + client: Any | None, + store: Any | None, +) -> Callable[..., Awaitable[list]]: + async def handle_archive( + event: IncomingCommand, auth_mgr, platform, chat_mgr, settings_mgr + ) -> list: + await chat_mgr.archive(event.chat_id, user_id=event.user_id) + + # Remove room from Space if client and store available + if client is not None and store is not None: + room_meta = await get_room_meta(store, event.chat_id) + space_id = (room_meta or {}).get("space_id") + if space_id: + # Find the matrix room_id — event.chat_id is the core chat_id (e.g. "C1"), + # but we need the matrix room_id for room_put_state. + # Actually, in Matrix adapter, event.chat_id IS the core chat_id resolved + # by room_router. We need the actual room_id. + # The room_id is the key used in room_meta store. We need to find which + # room_id maps to this chat_id. For now, check if event has surface info. + # + # IMPORTANT: In the Matrix adapter, commands are dispatched with chat_id + # from resolve_chat_id (e.g. "C1"). The actual room_id is available in + # the MatrixBot.on_room_message where room.room_id is known. + # Since handle_archive doesn't receive room_id, we need to find it. + # + # Solution: Store the room_id in the event's chat_id field. + # Actually, re-examining the flow: + # MatrixBot.on_room_message gets room.room_id, resolves to chat_id, + # then dispatches with chat_id. We lose room_id. + # + # Practical approach: iterate store isn't possible. + # Better approach: room_meta stores "room_id" -> meta with "chat_id". + # We can't reverse-lookup efficiently. + # + # Simplest fix: Store room_id in room_meta keyed by chat_id too, + # OR pass room_id through the event somehow. + # + # For Phase 1, use a pragmatic approach: the archive command responds + # with a message, but the Space child removal requires knowing the + # matrix room_id. Since we don't have it here, log a warning. + # The room will still be archived in core (chat_mgr.archive). + pass + + return [OutgoingMessage(chat_id=event.chat_id, text="Чат архивирован.")] + + return handle_archive +``` + +WAIT — the above approach has a problem. Let me reconsider. + +Actually, looking at the flow more carefully: +- `MatrixBot.on_room_message(room, event)` has `room.room_id` +- It calls `resolve_chat_id(store, room.room_id, sender)` to get chat_id like "C1" +- Then dispatches with that chat_id +- So `event.chat_id` in the handler is "C1", not the matrix room_id + +We need the matrix room_id for `room_put_state`. The cleanest Phase 1 solution: + +In `make_handle_archive(client, store)`, scan room_meta by iterating. But InMemoryStore and SQLiteStore don't have a scan/list method. + +**Better solution:** Change `room_router.resolve_chat_id` to store a reverse mapping `chat_id -> room_id` in room_meta. But that's in Plan 01's scope. + +**Simplest solution for Phase 1:** Use the fact that `get_room_meta` stores room_id as key. We need a helper that finds room_id by chat_id and user_id. Add to `adapter/matrix/store.py`: + +Actually, the simplest approach: the archive handler can look up user_meta to get space_id, and then we need the room_id. Since we only have chat_id ("C1") and user_id, we can't efficiently look up the room_id without a reverse index. + +**FINAL DECISION:** For Phase 1, `handle_archive` archives in core only (via chat_mgr.archive) and does NOT call room_put_state. This is acceptable because: +1. The room still exists, it's just marked archived in core +2. The user sees "Чат архивирован" message +3. Space child removal is a nice-to-have for Phase 1 (the room stays visible in Space but is archived logically) +4. Full Space child removal can be added when we add a reverse-lookup index + +So keep handle_archive simple: + +```python +def make_handle_archive( + client: Any | None, + store: Any | None, +) -> Callable[..., Awaitable[list]]: + async def handle_archive( + event: IncomingCommand, auth_mgr, platform, chat_mgr, settings_mgr + ) -> list: + await chat_mgr.archive(event.chat_id, user_id=event.user_id) + return [OutgoingMessage(chat_id=event.chat_id, text="Чат архивирован.")] + + return handle_archive +``` + +**Part B: Convert handle_rename to make_handle_rename(client, store)** + +```python +def make_handle_rename( + client: Any | None, + store: Any | None, +) -> Callable[..., Awaitable[list]]: + async def handle_rename( + event: IncomingCommand, auth_mgr, platform, chat_mgr, settings_mgr + ) -> list: + if not event.args: + return [OutgoingMessage(chat_id=event.chat_id, text="Укажите название: !rename Название")] + new_name = " ".join(event.args) + ctx = await chat_mgr.rename(event.chat_id, new_name, user_id=event.user_id) + return [OutgoingMessage(chat_id=event.chat_id, text=f"Переименован в: {ctx.display_name}")] + + return handle_rename +``` + +**Part C: Update `adapter/matrix/handlers/__init__.py`** + +Change the imports and registrations: + +Old imports: +```python +from adapter.matrix.handlers.chat import ( + handle_archive, + handle_list_chats, + make_handle_new_chat, + handle_rename, +) +``` + +New imports: +```python +from adapter.matrix.handlers.chat import ( + make_handle_archive, + handle_list_chats, + make_handle_new_chat, + make_handle_rename, +) +``` + +Old registrations: +```python +dispatcher.register(IncomingCommand, "archive", handle_archive) +dispatcher.register(IncomingCommand, "rename", handle_rename) +``` + +New registrations: +```python +dispatcher.register(IncomingCommand, "archive", make_handle_archive(client, store)) +dispatcher.register(IncomingCommand, "rename", make_handle_rename(client, store)) +``` + +Also keep the existing exports in `chat.py` module-level for backwards compatibility: add `handle_archive = make_handle_archive(None, None)` etc. at module bottom. Actually NO — just export the factory functions. Update __init__.py imports as shown above. + +Make sure `handle_list_chats` remains a plain function (no closure needed, it doesn't use client or store). + + + cd /Users/a/MAI/sem2/lambda/surfaces-bot && python -c "from adapter.matrix.handlers.chat import make_handle_archive, make_handle_rename, make_handle_new_chat, handle_list_chats; print('OK')" && python -c "from adapter.matrix.handlers import register_matrix_handlers; print('OK')" + + +- `adapter/matrix/handlers/chat.py` contains `def make_handle_archive(` +- `adapter/matrix/handlers/chat.py` contains `def make_handle_rename(` +- `adapter/matrix/handlers/chat.py` does NOT contain `async def handle_archive(` as a top-level function (it's inside the closure now) +- `adapter/matrix/handlers/__init__.py` contains `make_handle_archive(client, store)` +- `adapter/matrix/handlers/__init__.py` contains `make_handle_rename(client, store)` +- `python -c "from adapter.matrix.handlers import register_matrix_handlers"` succeeds + + handle_archive and handle_rename are closure factories; __init__.py registrations updated + + + + + +After both tasks: +- `python -c "from adapter.matrix.handlers import register_matrix_handlers; print('OK')"` succeeds +- `python -c "from adapter.matrix.handlers.chat import make_handle_new_chat, make_handle_archive, make_handle_rename, handle_list_chats; print('OK')"` succeeds + + + +- make_handle_new_chat creates rooms inside Space with room_put_state +- make_handle_archive is a closure factory (Phase 1: core archive only, no Space child removal) +- make_handle_rename is a closure factory +- __init__.py updated to use factory calls +- All imports resolve cleanly + + + +After completion, create `.planning/phases/01-matrix-qa-polish/01-02-SUMMARY.md` + diff --git a/.planning/phases/01-matrix-qa-polish/01-03-PLAN.md b/.planning/phases/01-matrix-qa-polish/01-03-PLAN.md new file mode 100644 index 0000000..479fb2a --- /dev/null +++ b/.planning/phases/01-matrix-qa-polish/01-03-PLAN.md @@ -0,0 +1,542 @@ +--- +phase: 01-matrix-qa-polish +plan: 03 +type: execute +wave: 2 +depends_on: ["01-01"] +files_modified: + - adapter/matrix/bot.py + - adapter/matrix/reactions.py + - adapter/matrix/handlers/confirm.py + - adapter/matrix/handlers/settings.py +autonomous: true +requirements: [] + +must_haves: + truths: + - "OutgoingUI renders as text + '!yes / !no' hint, no m.reaction events sent" + - "_button_action_to_reaction function is removed from bot.py" + - "on_reaction callback is removed from bot.py" + - "ReactionEvent import is removed from bot.py" + - "build_skills_text no longer mentions reactions 1-9" + - "build_confirmation_text uses !yes/!no instead of reaction emojis" + - "!yes reads pending_confirm from store and returns action description" + - "!no clears pending_confirm and returns cancellation message" + - "!settings returns a read-only dashboard with skills/soul/safety/chats status" + artifacts: + - path: "adapter/matrix/bot.py" + provides: "Clean send_outgoing without reactions, pending_confirm storage on OutgoingUI" + contains: "!yes" + - path: "adapter/matrix/reactions.py" + provides: "Updated text builders without reaction references" + - path: "adapter/matrix/handlers/confirm.py" + provides: "!yes/!no handlers reading pending_confirm" + contains: "get_pending_confirm" + - path: "adapter/matrix/handlers/settings.py" + provides: "Read-only dashboard for !settings" + key_links: + - from: "adapter/matrix/bot.py" + to: "adapter/matrix/store.py" + via: "set_pending_confirm on OutgoingUI send" + pattern: "set_pending_confirm" + - from: "adapter/matrix/handlers/confirm.py" + to: "adapter/matrix/store.py" + via: "get_pending_confirm / clear_pending_confirm" + pattern: "get_pending_confirm" +--- + + +Remove all reaction-based UX from the Matrix adapter and replace with text-based !yes/!no confirmation. Update settings dashboard to read-only format. + +Purpose: Per D-06/D-07/D-08, reactions are removed entirely. OutgoingUI renders as plain text with !yes/!no hint. Per D-12, !settings becomes a read-only dashboard. + +Output: Clean bot.py without reactions, working !yes/!no confirmation flow, updated text builders, read-only settings dashboard. + + + +@$HOME/.claude/get-shit-done/workflows/execute-plan.md +@$HOME/.claude/get-shit-done/templates/summary.md + + + +@.planning/PROJECT.md +@.planning/ROADMAP.md +@.planning/phases/01-matrix-qa-polish/01-CONTEXT.md +@.planning/phases/01-matrix-qa-polish/01-RESEARCH.md + +@adapter/matrix/bot.py +@adapter/matrix/reactions.py +@adapter/matrix/handlers/confirm.py +@adapter/matrix/handlers/settings.py +@adapter/matrix/store.py +@adapter/matrix/converter.py +@core/protocol.py + + + + +```python +PENDING_CONFIRM_PREFIX = "matrix_pending_confirm:" + +async def get_pending_confirm(store: StateStore, room_id: str) -> dict | None +async def set_pending_confirm(store: StateStore, room_id: str, meta: dict) -> None +async def clear_pending_confirm(store: StateStore, room_id: str) -> None +``` + + + +```python +@dataclass +class UIButton: + label: str + action: str + payload: dict = field(default_factory=dict) + style: str = "secondary" + +@dataclass +class OutgoingUI: + chat_id: str + text: str + buttons: list[UIButton] = field(default_factory=list) + +@dataclass +class IncomingCallback: + user_id: str + platform: str + chat_id: str + action: str + payload: dict = field(default_factory=dict) +``` + + + +```python +# In from_command(): +if command in {"yes", "no"}: + action = "confirm" if command == "yes" else "cancel" + return IncomingCallback( + user_id=sender, + platform=PLATFORM, + chat_id=chat_id, + action=action, + payload={"source": "command", "command": command}, + ) +``` + + + +```python +dispatcher.register(IncomingCallback, "confirm", handle_confirm) +dispatcher.register(IncomingCallback, "cancel", handle_cancel) +``` + + + +```python +@dataclass +class UserSettings: + skills: dict + connectors: dict + soul: dict + safety: dict + plan: dict +``` + + + + + + + Task 1: Remove reactions from bot.py, update send_outgoing for !yes/!no (per D-06, D-07) + adapter/matrix/bot.py + adapter/matrix/bot.py, adapter/matrix/store.py, core/protocol.py + +Modify `adapter/matrix/bot.py` with these specific changes: + +**1. Remove ReactionEvent import (line 14):** +Change the nio import block from: +```python +from nio import ( + AsyncClient, + AsyncClientConfig, + InviteMemberEvent, + MatrixRoom, + ReactionEvent, + RoomMemberEvent, + RoomMessageText, +) +``` +to: +```python +from nio import ( + AsyncClient, + AsyncClientConfig, + InviteMemberEvent, + MatrixRoom, + RoomMemberEvent, + RoomMessageText, +) +``` + +**2. Remove `from_reaction` import (line 20):** +Change: +```python +from adapter.matrix.converter import from_reaction, from_room_event +``` +to: +```python +from adapter.matrix.converter import from_room_event +``` + +**3. Add store import for pending_confirm:** +Add this import: +```python +from adapter.matrix.store import set_pending_confirm +``` + +**4. Delete the entire `on_reaction` method from MatrixBot class (lines 106-114).** + +**5. Delete the entire `_button_action_to_reaction` function (lines 135-140).** + +**6. Rewrite the OutgoingUI block in `send_outgoing` function.** +Replace the existing `if isinstance(event, OutgoingUI):` block (lines 154-180) with: + +```python + if isinstance(event, OutgoingUI): + lines = [event.text] + if event.buttons: + lines.append("") + for btn in event.buttons: + lines.append(f" {btn.label}") + lines.append("") + lines.append("Ответьте !yes для подтверждения или !no для отмены.") + body = "\n".join(lines) + await client.room_send(room_id, "m.room.message", {"msgtype": "m.text", "body": body}) + # Store pending confirmation for !yes/!no handler + if event.buttons: + action_id = event.buttons[0].action if event.buttons else "unknown" + payload = event.buttons[0].payload if event.buttons else {} + await set_pending_confirm(store, room_id, { + "action_id": action_id, + "description": event.text, + "payload": payload, + }) + return +``` + +**PROBLEM:** `send_outgoing` is a module-level function with signature `async def send_outgoing(client, room_id, event)`. It doesn't receive `store`. We need to pass `store` to it. + +**Solution:** Change `send_outgoing` signature to include `store`: +```python +async def send_outgoing(client: AsyncClient, room_id: str, event: OutgoingEvent, store: StateStore | None = None) -> None: +``` + +And update `MatrixBot._send_all` to pass store: +```python + async def _send_all(self, room_id: str, outgoing: list[OutgoingEvent]) -> None: + for event in outgoing: + await send_outgoing(self.client, room_id, event, store=self.runtime.store) +``` + +**7. In `main()`, remove the on_reaction callback registration.** +Delete this line: +```python + client.add_event_callback(bot.on_reaction, ReactionEvent) +``` + +**8. Add StateStore import at top:** +```python +from core.store import InMemoryStore, SQLiteStore, StateStore +``` +(StateStore is already imported on line 37 — verify it's there.) + +The `set_pending_confirm` call in the OutgoingUI handler should guard against store being None: +```python + if event.buttons and store is not None: + action_id = event.buttons[0].action + payload = event.buttons[0].payload + await set_pending_confirm(store, room_id, { + "action_id": action_id, + "description": event.text, + "payload": payload, + }) +``` + + + cd /Users/a/MAI/sem2/lambda/surfaces-bot && python -c "from adapter.matrix.bot import send_outgoing, MatrixBot, build_runtime; print('OK')" && python -c "import ast; tree = ast.parse(open('adapter/matrix/bot.py').read()); names = [n.name for n in ast.walk(tree) if isinstance(n, (ast.FunctionDef, ast.AsyncFunctionDef))]; assert '_button_action_to_reaction' not in names, 'reaction helper still exists'; assert 'on_reaction' not in names, 'on_reaction still exists'; print('REACTION CODE REMOVED')" + + +- `adapter/matrix/bot.py` does NOT contain the string `_button_action_to_reaction` +- `adapter/matrix/bot.py` does NOT contain the string `on_reaction` +- `adapter/matrix/bot.py` does NOT contain `ReactionEvent` +- `adapter/matrix/bot.py` does NOT contain `from_reaction` +- `adapter/matrix/bot.py` does NOT contain `m.reaction` +- `adapter/matrix/bot.py` contains `Ответьте !yes для подтверждения или !no для отмены.` +- `adapter/matrix/bot.py` contains `set_pending_confirm` +- `send_outgoing` function signature includes `store` parameter + + bot.py has no reaction code; OutgoingUI renders text + !yes/!no; pending_confirm stored on OutgoingUI send + + + + Task 2: Update reactions.py text builders + confirm.py handlers + settings.py dashboard (per D-06, D-07, D-08, D-12) + adapter/matrix/reactions.py, adapter/matrix/handlers/confirm.py, adapter/matrix/handlers/settings.py + adapter/matrix/reactions.py, adapter/matrix/handlers/confirm.py, adapter/matrix/handlers/settings.py, adapter/matrix/store.py + +**Part A: Update adapter/matrix/reactions.py** + +1. Update `build_skills_text` — replace the last line "Реакции 1-9 переключают навыки." with instruction for text commands: + +Replace: +```python + lines.append("Реакции 1️⃣-9️⃣ переключают навыки.") +``` +With: +```python + lines.append("!skill on/off <название> — переключить навык.") +``` + +2. Update `build_confirmation_text` — remove reaction emojis, use only !yes/!no: + +Replace the entire function with: +```python +def build_confirmation_text(description: str) -> str: + return "\n".join( + [ + "Lambda", + description, + "", + "Ответьте !yes для подтверждения или !no для отмены.", + ] + ) +``` + +3. Remove `add_reaction` and `remove_reaction` functions entirely (they send m.reaction events which are no longer used). + +4. Keep `CONFIRM_REACTION`, `CANCEL_REACTION`, `SKILL_REACTIONS`, `REACTION_TO_INDEX`, `reaction_to_skill_index` — they are still imported by `converter.py` for `from_reaction`. Even though `from_reaction` is no longer called from bot.py, converter.py still exports it and removing would break imports. Keep for backwards compat. + +Actually, check: `from_reaction` is imported in `converter.py` definition, not as an external import. And `bot.py` no longer imports `from_reaction`. But `converter.py` imports `CANCEL_REACTION, CONFIRM_REACTION, reaction_to_skill_index` from `reactions.py`. So those constants MUST stay. + +Keep: `CONFIRM_REACTION`, `CANCEL_REACTION`, `SKILL_REACTIONS`, `REACTION_TO_INDEX`, `reaction_to_skill_index`, `build_skills_text`, `build_confirmation_text`. +Remove: `add_reaction`, `remove_reaction`. +Remove the `AsyncClient` import since add_reaction/remove_reaction used it and nothing else does. + +Updated file should look like: +```python +from __future__ import annotations + +from sdk.interface import UserSettings + +CONFIRM_REACTION = "👍" +CANCEL_REACTION = "❌" +SKILL_REACTIONS = ["1️⃣", "2️⃣", "3️⃣", "4️⃣", "5️⃣", "6️⃣", "7️⃣", "8️⃣", "9️⃣"] +REACTION_TO_INDEX = {emoji: idx + 1 for idx, emoji in enumerate(SKILL_REACTIONS)} + + +def build_skills_text(settings: UserSettings) -> str: + lines: list[str] = ["Скиллы"] + for idx, (name, enabled) in enumerate(settings.skills.items(), start=1): + state = "on" if enabled else "off" + emoji = SKILL_REACTIONS[idx - 1] if idx - 1 < len(SKILL_REACTIONS) else f"{idx}." + lines.append(f" {state} {emoji} {name}") + lines.append("") + lines.append("!skill on/off <название> — переключить навык.") + return "\n".join(lines) + + +def build_confirmation_text(description: str) -> str: + return "\n".join( + [ + "Lambda", + description, + "", + "Ответьте !yes для подтверждения или !no для отмены.", + ] + ) + + +def reaction_to_skill_index(key: str) -> int | None: + return REACTION_TO_INDEX.get(key) +``` + +**Part B: Update adapter/matrix/handlers/confirm.py** + +Rewrite to read pending_confirm from store. The handlers receive the standard signature `(event, auth_mgr, platform, chat_mgr, settings_mgr)` but need access to `store`. Since they're registered in `__init__.py` as plain functions (not closures), convert them to closure factories. + +Replace entire file: + +```python +from __future__ import annotations + +from adapter.matrix.store import get_pending_confirm, clear_pending_confirm +from core.protocol import IncomingCallback, OutgoingMessage + + +def make_handle_confirm(store=None): + async def handle_confirm( + event: IncomingCallback, auth_mgr, platform, chat_mgr, settings_mgr + ) -> list: + if store is None: + return [OutgoingMessage(chat_id=event.chat_id, text="Нет ожидающих подтверждений.")] + + pending = await get_pending_confirm(store, event.chat_id) + if not pending: + return [OutgoingMessage(chat_id=event.chat_id, text="Нет ожидающих подтверждений.")] + + description = pending.get("description", "действие") + action_id = pending.get("action_id", "unknown") + await clear_pending_confirm(store, event.chat_id) + + return [ + OutgoingMessage( + chat_id=event.chat_id, + text=f"Подтверждено: {description}", + ) + ] + + return handle_confirm + + +def make_handle_cancel(store=None): + async def handle_cancel( + event: IncomingCallback, auth_mgr, platform, chat_mgr, settings_mgr + ) -> list: + if store is None: + return [OutgoingMessage(chat_id=event.chat_id, text="Нет ожидающих подтверждений.")] + + pending = await get_pending_confirm(store, event.chat_id) + if not pending: + return [OutgoingMessage(chat_id=event.chat_id, text="Нет ожидающих подтверждений.")] + + await clear_pending_confirm(store, event.chat_id) + + return [ + OutgoingMessage( + chat_id=event.chat_id, + text="Действие отменено.", + ) + ] + + return handle_cancel +``` + +**Part C: Update adapter/matrix/handlers/__init__.py for new confirm imports** + +Change confirm imports from: +```python +from adapter.matrix.handlers.confirm import handle_cancel, handle_confirm +``` +to: +```python +from adapter.matrix.handlers.confirm import make_handle_cancel, make_handle_confirm +``` + +Change registrations from: +```python + dispatcher.register(IncomingCallback, "confirm", handle_confirm) + dispatcher.register(IncomingCallback, "cancel", handle_cancel) +``` +to: +```python + dispatcher.register(IncomingCallback, "confirm", make_handle_confirm(store)) + dispatcher.register(IncomingCallback, "cancel", make_handle_cancel(store)) +``` + +**Part D: Update adapter/matrix/handlers/settings.py — handle_settings becomes read-only dashboard (per D-12)** + +Replace the `handle_settings` function body. Keep ALL other functions unchanged. + +```python +async def handle_settings( + event: IncomingCommand, auth_mgr, platform, chat_mgr, settings_mgr +) -> list: + settings = await settings_mgr.get(event.user_id) + chats = await chat_mgr.list_active(event.user_id) + + # Skills section + skills_lines = [] + for name, enabled in settings.skills.items(): + state = "on" if enabled else "off" + skills_lines.append(f" {state} {name}") + skills_text = "\n".join(skills_lines) if skills_lines else " нет навыков" + + # Soul section + soul_lines = [] + for key, value in (settings.soul or {}).items(): + soul_lines.append(f" {key}: {value}") + soul_text = "\n".join(soul_lines) if soul_lines else " по умолчанию" + + # Safety section + safety_lines = [] + for key, value in (settings.safety or {}).items(): + state = "on" if value else "off" + safety_lines.append(f" {state} {key}") + safety_text = "\n".join(safety_lines) if safety_lines else " по умолчанию" + + # Chats section + chat_lines = [f" {c.display_name} ({c.chat_id})" for c in chats] + chats_text = "\n".join(chat_lines) if chat_lines else " нет активных чатов" + + dashboard = "\n".join([ + "Настройки", + "", + "Скиллы:", + skills_text, + "", + "Личность:", + soul_text, + "", + "Безопасность:", + safety_text, + "", + f"Активные чаты ({len(chats)}):", + chats_text, + "", + "Изменить: !skills, !soul, !safety", + ]) + + return [OutgoingMessage(chat_id=event.chat_id, text=dashboard)] +``` + + + cd /Users/a/MAI/sem2/lambda/surfaces-bot && python -c "from adapter.matrix.reactions import build_skills_text, build_confirmation_text; from adapter.matrix.handlers.confirm import make_handle_confirm, make_handle_cancel; from adapter.matrix.handlers.settings import handle_settings; print('OK')" && python -c "from adapter.matrix.handlers import register_matrix_handlers; print('OK')" + + +- `adapter/matrix/reactions.py` does NOT contain `add_reaction` +- `adapter/matrix/reactions.py` does NOT contain `remove_reaction` +- `adapter/matrix/reactions.py` does NOT contain the string `Реакции 1` +- `adapter/matrix/reactions.py` contains `!skill on/off` +- `adapter/matrix/reactions.py` contains `!yes` in build_confirmation_text +- `adapter/matrix/handlers/confirm.py` contains `get_pending_confirm` +- `adapter/matrix/handlers/confirm.py` contains `clear_pending_confirm` +- `adapter/matrix/handlers/confirm.py` contains `def make_handle_confirm(` +- `adapter/matrix/handlers/confirm.py` contains `def make_handle_cancel(` +- `adapter/matrix/handlers/__init__.py` contains `make_handle_confirm(store)` +- `adapter/matrix/handlers/__init__.py` contains `make_handle_cancel(store)` +- `adapter/matrix/handlers/settings.py` `handle_settings` function contains the string `Настройки` and `Скиллы:` and `Изменить:` +- `adapter/matrix/handlers/settings.py` `handle_settings` does NOT contain `!connectors` or `!plan` or `!status` or `!whoami` + + Reactions removed from text builders; !yes/!no handlers read pending_confirm; !settings is read-only dashboard + + + + + +After both tasks: +- `python -c "from adapter.matrix.bot import send_outgoing, MatrixBot; from adapter.matrix.reactions import build_skills_text; from adapter.matrix.handlers.confirm import make_handle_confirm; from adapter.matrix.handlers import register_matrix_handlers; print('ALL OK')"` +- No string `m.reaction` in `adapter/matrix/bot.py` +- No string `_button_action_to_reaction` in `adapter/matrix/bot.py` +- No string `Реакции 1` in `adapter/matrix/reactions.py` + + + +- bot.py: no reaction code, OutgoingUI renders text + !yes/!no, stores pending_confirm +- reactions.py: build_skills_text says "!skill on/off", build_confirmation_text says "!yes/!no" +- confirm.py: !yes reads pending_confirm and confirms, !no clears and cancels +- settings.py: !settings returns read-only dashboard +- All imports resolve + + + +After completion, create `.planning/phases/01-matrix-qa-polish/01-03-SUMMARY.md` + diff --git a/.planning/phases/01-matrix-qa-polish/01-04-PLAN.md b/.planning/phases/01-matrix-qa-polish/01-04-PLAN.md new file mode 100644 index 0000000..e30dbda --- /dev/null +++ b/.planning/phases/01-matrix-qa-polish/01-04-PLAN.md @@ -0,0 +1,825 @@ +--- +phase: 01-matrix-qa-polish +plan: 04 +type: execute +wave: 3 +depends_on: ["01-01", "01-02", "01-03"] +files_modified: + - tests/adapter/matrix/test_dispatcher.py + - tests/adapter/matrix/test_reactions.py + - tests/adapter/matrix/test_store.py + - tests/adapter/matrix/test_invite_space.py + - tests/adapter/matrix/test_chat_space.py + - tests/adapter/matrix/test_send_outgoing.py + - tests/adapter/matrix/test_confirm.py +autonomous: true +requirements: [] + +must_haves: + truths: + - "All 4 previously-broken tests are fixed and green" + - "12 new tests (MAT-01..MAT-12) are implemented and green" + - "pytest tests/ -q shows 96+ tests passing" + - "No test uses hardcoded 'C1' assumption from old DM flow" + artifacts: + - path: "tests/adapter/matrix/test_invite_space.py" + provides: "MAT-01, MAT-02, MAT-03 tests" + contains: "space=True" + - path: "tests/adapter/matrix/test_chat_space.py" + provides: "MAT-04, MAT-05, MAT-10, MAT-12 tests" + contains: "room_put_state" + - path: "tests/adapter/matrix/test_send_outgoing.py" + provides: "MAT-06, MAT-07 tests" + contains: "!yes" + - path: "tests/adapter/matrix/test_confirm.py" + provides: "MAT-09 test" + contains: "get_pending_confirm" + - path: "tests/adapter/matrix/test_dispatcher.py" + provides: "Fixed broken tests + MAT-11" + - path: "tests/adapter/matrix/test_reactions.py" + provides: "Fixed broken tests" + - path: "tests/adapter/matrix/test_store.py" + provides: "MAT-08 pending_confirm roundtrip test" + contains: "pending_confirm" + key_links: + - from: "tests/adapter/matrix/test_invite_space.py" + to: "adapter/matrix/handlers/auth.py" + via: "tests handle_invite" + pattern: "handle_invite" + - from: "tests/adapter/matrix/test_chat_space.py" + to: "adapter/matrix/handlers/chat.py" + via: "tests make_handle_new_chat" + pattern: "make_handle_new_chat" +--- + + +Fix all broken tests and implement 12 new test cases (MAT-01..MAT-12) covering the Space+rooms refactor. + +Purpose: Achieve 96+ green tests as required by Phase 1 deliverables. Currently 97 pass; 4 will break from Plans 01-03 changes. This plan fixes those 4 and adds 12 new, targeting ~109 total. + +Output: Full green test suite with comprehensive Space+rooms coverage. + + + +@$HOME/.claude/get-shit-done/workflows/execute-plan.md +@$HOME/.claude/get-shit-done/templates/summary.md + + + +@.planning/PROJECT.md +@.planning/ROADMAP.md +@.planning/phases/01-matrix-qa-polish/01-CONTEXT.md +@.planning/phases/01-matrix-qa-polish/01-RESEARCH.md +@.planning/phases/01-matrix-qa-polish/01-VALIDATION.md + +@tests/adapter/matrix/test_dispatcher.py +@tests/adapter/matrix/test_reactions.py +@tests/adapter/matrix/test_store.py +@adapter/matrix/handlers/auth.py +@adapter/matrix/handlers/chat.py +@adapter/matrix/handlers/confirm.py +@adapter/matrix/handlers/settings.py +@adapter/matrix/bot.py +@adapter/matrix/store.py +@adapter/matrix/reactions.py +@adapter/matrix/converter.py +@core/protocol.py + + + + +```python +# adapter/matrix/handlers/auth.py +async def handle_invite(client, room, event, platform, store, auth_mgr) -> None +# Creates Space (space=True), chat room, room_put_state, room_invite x2, stores user_meta+room_meta + +# adapter/matrix/store.py +async def get_pending_confirm(store: StateStore, room_id: str) -> dict | None +async def set_pending_confirm(store: StateStore, room_id: str, meta: dict) -> None +async def clear_pending_confirm(store: StateStore, room_id: str) -> None + +# adapter/matrix/handlers/chat.py +def make_handle_new_chat(client, store) -> Callable # closure factory +def make_handle_archive(client, store) -> Callable # closure factory +def make_handle_rename(client, store) -> Callable # closure factory + +# adapter/matrix/handlers/confirm.py +def make_handle_confirm(store=None) -> Callable # closure factory +def make_handle_cancel(store=None) -> Callable # closure factory + +# adapter/matrix/bot.py +async def send_outgoing(client, room_id, event, store=None) -> None +# For OutgoingUI: renders text + "!yes/!no", calls set_pending_confirm + +# adapter/matrix/reactions.py +def build_skills_text(settings) -> str # No longer mentions "Реакции 1-9" +def build_confirmation_text(description) -> str # Uses "!yes/!no" not emojis +``` + + + +```python +class InMemoryStore: + async def get(key) -> Any + async def set(key, value) -> None + async def delete(key) -> None # Check if exists; if not, use set(key, None) +``` + + + +```python +class MockPlatformClient: + # Provides get_or_create_user, get_settings, etc. +``` + + + +```python +@dataclass +class UserSettings: + skills: dict + connectors: dict + soul: dict + safety: dict + plan: dict +``` + + + + + + + Task 1: Fix 4 broken tests in test_dispatcher.py and test_reactions.py + tests/adapter/matrix/test_dispatcher.py, tests/adapter/matrix/test_reactions.py + tests/adapter/matrix/test_dispatcher.py, tests/adapter/matrix/test_reactions.py, adapter/matrix/handlers/auth.py, adapter/matrix/handlers/chat.py, adapter/matrix/bot.py, adapter/matrix/reactions.py, adapter/matrix/store.py + +**Fix 1: test_dispatcher.py::test_invite_event_creates_dm_room_and_sends_welcome** + +The old test checks `client.join` and `meta["chat_id"] == "C1"` via room_meta on the DM room. After refactor, handle_invite creates a Space + chat room, so the test needs different mocks and assertions. + +Replace the entire test function with: + +```python +async def test_invite_event_creates_space_and_chat_room(): + from adapter.matrix.store import get_user_meta, get_room_meta + + runtime = build_runtime(platform=MockPlatformClient()) + # Mock client with room_create, room_put_state, room_invite, room_send, join + space_resp = SimpleNamespace(room_id="!space:example.org") + chat_resp = SimpleNamespace(room_id="!chat1:example.org") + client = SimpleNamespace( + join=AsyncMock(), + room_create=AsyncMock(side_effect=[space_resp, chat_resp]), + room_put_state=AsyncMock(), + room_invite=AsyncMock(), + room_send=AsyncMock(), + ) + room = SimpleNamespace(room_id="!dm:example.org", display_name="Alice") + event = SimpleNamespace(sender="@alice:example.org", membership="invite") + + await handle_invite(client, room, event, runtime.platform, runtime.store, runtime.auth_mgr) + + # Verify Space created with space=True + assert client.room_create.await_count == 2 + first_call = client.room_create.call_args_list[0] + assert first_call.kwargs.get("space") is True or (len(first_call.args) > 0 and first_call.kwargs.get("space") is True) + + # Verify room_put_state called to add child to Space + client.room_put_state.assert_awaited_once() + put_state_call = client.room_put_state.call_args + assert put_state_call.kwargs.get("event_type") == "m.space.child" or put_state_call.args[1] == "m.space.child" + + # Verify user_meta has space_id + user_meta = await get_user_meta(runtime.store, "@alice:example.org") + assert user_meta is not None + assert user_meta.get("space_id") == "!space:example.org" + + # Verify room_meta for chat room + room_meta = await get_room_meta(runtime.store, "!chat1:example.org") + assert room_meta is not None + assert room_meta["chat_id"] == "C1" + assert room_meta["space_id"] == "!space:example.org" + + # Verify auth confirmed + assert await runtime.auth_mgr.is_authenticated("@alice:example.org") is True + + # Verify welcome message sent + client.room_send.assert_awaited_once() +``` + +Also add import at top if not present: +```python +from adapter.matrix.store import get_user_meta, get_room_meta +``` +(get_room_meta is already imported) + +**Fix 2: test_dispatcher.py::test_invite_event_is_idempotent_per_room** + +This test now needs to check idempotency on user_meta (not room_meta). Replace with: + +```python +async def test_invite_event_is_idempotent_per_user(): + runtime = build_runtime(platform=MockPlatformClient()) + space_resp = SimpleNamespace(room_id="!space:example.org") + chat_resp = SimpleNamespace(room_id="!chat1:example.org") + client = SimpleNamespace( + join=AsyncMock(), + room_create=AsyncMock(side_effect=[space_resp, chat_resp]), + room_put_state=AsyncMock(), + room_invite=AsyncMock(), + room_send=AsyncMock(), + ) + room = SimpleNamespace(room_id="!dm:example.org", display_name="Alice") + event = SimpleNamespace(sender="@alice:example.org", membership="invite") + + await handle_invite(client, room, event, runtime.platform, runtime.store, runtime.auth_mgr) + # Second call should be a no-op (user already has space_id) + await handle_invite(client, room, event, runtime.platform, runtime.store, runtime.auth_mgr) + + # room_create called only twice (once for Space, once for chat room) — not 4 times + assert client.room_create.await_count == 2 +``` + +**Fix 3: test_dispatcher.py::test_new_chat_creates_real_matrix_room_when_client_available** + +After refactor, make_handle_new_chat needs space_id in user_meta and calls room_put_state. Update: + +```python +async def test_new_chat_creates_real_matrix_room_when_client_available(): + from adapter.matrix.store import set_user_meta + + client = SimpleNamespace( + room_create=AsyncMock(return_value=SimpleNamespace(room_id="!r2:example")), + room_put_state=AsyncMock(), + room_invite=AsyncMock(), + ) + runtime = build_runtime(platform=MockPlatformClient(), client=client) + + # Pre-populate user_meta with space_id (as if invite flow already ran) + await set_user_meta(runtime.store, "u1", {"space_id": "!space:example", "next_chat_index": 1}) + + start = IncomingCommand(user_id="u1", platform="matrix", chat_id="C1", command="start") + await runtime.dispatcher.dispatch(start) + + new = IncomingCommand( + user_id="u1", + platform="matrix", + chat_id="C1", + command="new", + args=["Research"], + ) + result = await runtime.dispatcher.dispatch(new) + + client.room_create.assert_awaited_once_with(name="Research", visibility="private", is_direct=False) + client.room_put_state.assert_awaited_once() + # Verify room_put_state adds child to space + put_call = client.room_put_state.call_args + assert put_call.kwargs.get("room_id") == "!space:example" or put_call.args[0] == "!space:example" + + assert any(isinstance(r, OutgoingMessage) and "Research" in r.text for r in result) +``` + +**Fix 4: test_dispatcher.py::test_matrix_dispatcher_registers_custom_handlers** + +This test checks `"Реакции 1️⃣-9️⃣" in r.text` on line 39. After reactions removal, this string no longer appears. Update: + +Change line 39 from: +```python + assert any(isinstance(r, OutgoingMessage) and "Реакции 1️⃣-9️⃣" in r.text for r in result) +``` +to: +```python + assert any(isinstance(r, OutgoingMessage) and "!skill on/off" in r.text for r in result) +``` + +**Fix 5: test_reactions.py::test_build_skills_text** + +Change assertion from: +```python + assert "Реакции 1️⃣-9️⃣" in text +``` +to: +```python + assert "!skill on/off" in text +``` + +**Fix 6: test_reactions.py::test_build_confirmation_text** + +The old test checks for "подтвердить" which may still be in the text. Update to check for new format: + +```python +def test_build_confirmation_text(): + text = build_confirmation_text("Отправить письмо?") + assert "Отправить письмо?" in text + assert "!yes" in text + assert "!no" in text +``` + +Also make sure the `get_room_meta` import and `get_user_meta` import are present in test_dispatcher.py. Add `from adapter.matrix.store import get_user_meta, set_user_meta` if not already imported. + + + cd /Users/a/MAI/sem2/lambda/surfaces-bot && pytest tests/adapter/matrix/test_dispatcher.py tests/adapter/matrix/test_reactions.py -x -q 2>&1 | tail -5 + + +- `test_dispatcher.py` does NOT contain `test_invite_event_creates_dm_room_and_sends_welcome` (renamed to `test_invite_event_creates_space_and_chat_room`) +- `test_dispatcher.py` contains `test_invite_event_creates_space_and_chat_room` +- `test_dispatcher.py` contains `space=True` in assertions +- `test_dispatcher.py` contains `room_put_state` in assertions +- `test_reactions.py` contains `!skill on/off` instead of `Реакции 1` +- `test_reactions.py` contains `!yes` in confirmation text test +- `pytest tests/adapter/matrix/test_dispatcher.py tests/adapter/matrix/test_reactions.py -x -q` passes + + All 4 previously-broken tests fixed and passing (renamed/updated for Space+rooms) + + + + Task 2: Create new test files and implement MAT-01..MAT-12 + tests/adapter/matrix/test_invite_space.py, tests/adapter/matrix/test_chat_space.py, tests/adapter/matrix/test_send_outgoing.py, tests/adapter/matrix/test_confirm.py, tests/adapter/matrix/test_store.py, tests/adapter/matrix/test_dispatcher.py + adapter/matrix/handlers/auth.py, adapter/matrix/handlers/chat.py, adapter/matrix/bot.py, adapter/matrix/handlers/confirm.py, adapter/matrix/handlers/settings.py, adapter/matrix/store.py, tests/adapter/matrix/test_store.py, tests/adapter/matrix/test_dispatcher.py + +Create 4 new test files and extend 2 existing ones. All tests use `pytest-asyncio` (async test functions are auto-detected). + +**File 1: tests/adapter/matrix/test_invite_space.py (MAT-01, MAT-02, MAT-03)** + +```python +from __future__ import annotations + +from types import SimpleNamespace +from unittest.mock import AsyncMock + +from adapter.matrix.handlers.auth import handle_invite +from adapter.matrix.store import get_user_meta, get_room_meta +from adapter.matrix.bot import build_runtime +from sdk.mock import MockPlatformClient + + +def _make_client(): + """Helper: create mock client with Space+room creation responses.""" + space_resp = SimpleNamespace(room_id="!space:example.org") + chat_resp = SimpleNamespace(room_id="!chat1:example.org") + return SimpleNamespace( + join=AsyncMock(), + room_create=AsyncMock(side_effect=[space_resp, chat_resp]), + room_put_state=AsyncMock(), + room_invite=AsyncMock(), + room_send=AsyncMock(), + ) + + +async def test_mat01_invite_creates_space_and_chat1(): + """MAT-01: handle_invite creates Space + Чат 1, saves space_id in user_meta.""" + runtime = build_runtime(platform=MockPlatformClient()) + client = _make_client() + room = SimpleNamespace(room_id="!dm:example.org", display_name="Alice") + event = SimpleNamespace(sender="@alice:example.org", membership="invite") + + await handle_invite(client, room, event, runtime.platform, runtime.store, runtime.auth_mgr) + + # Space created with space=True + first_call = client.room_create.call_args_list[0] + assert first_call.kwargs.get("space") is True + + # Chat room created + assert client.room_create.await_count == 2 + + # room_put_state links child to Space + client.room_put_state.assert_awaited_once() + ps_kwargs = client.room_put_state.call_args.kwargs + assert ps_kwargs.get("event_type") == "m.space.child" + assert ps_kwargs.get("state_key") == "!chat1:example.org" + assert ps_kwargs.get("room_id") == "!space:example.org" + + # user_meta stores space_id + user_meta = await get_user_meta(runtime.store, "@alice:example.org") + assert user_meta is not None + assert user_meta["space_id"] == "!space:example.org" + + # room_meta stores chat metadata + room_meta = await get_room_meta(runtime.store, "!chat1:example.org") + assert room_meta is not None + assert room_meta["chat_id"] == "C1" + assert room_meta["space_id"] == "!space:example.org" + + +async def test_mat02_invite_idempotent(): + """MAT-02: Repeated invite does not create second Space.""" + runtime = build_runtime(platform=MockPlatformClient()) + client = _make_client() + room = SimpleNamespace(room_id="!dm:example.org", display_name="Alice") + event = SimpleNamespace(sender="@alice:example.org", membership="invite") + + await handle_invite(client, room, event, runtime.platform, runtime.store, runtime.auth_mgr) + + # Reset side_effect for potential second call + client.room_create.side_effect = None + client.room_create.return_value = SimpleNamespace(room_id="!should-not-exist:example.org") + + await handle_invite(client, room, event, runtime.platform, runtime.store, runtime.auth_mgr) + + # Still only 2 room_create calls (from first invite) + assert client.room_create.await_count == 2 + + +async def test_mat03_no_hardcoded_c1(): + """MAT-03: handle_invite uses next_chat_id, not hardcoded 'C1'.""" + import ast + import inspect + source = inspect.getsource(handle_invite) + # Check that the literal string '"C1"' or "'C1'" does not appear as a value assignment + assert '"C1"' not in source or "chat_id" not in source.split('"C1"')[0].split("\n")[-1] + # More robust: verify via actual behavior — chat_id comes from next_chat_id + runtime = build_runtime(platform=MockPlatformClient()) + client = _make_client() + room = SimpleNamespace(room_id="!dm:example.org", display_name="Alice") + event = SimpleNamespace(sender="@alice:example.org", membership="invite") + + await handle_invite(client, room, event, runtime.platform, runtime.store, runtime.auth_mgr) + + room_meta = await get_room_meta(runtime.store, "!chat1:example.org") + # C1 is correct for first user, but it came from next_chat_id (not hardcode) + assert room_meta["chat_id"] == "C1" + + # Verify next_chat_index was incremented (proves next_chat_id was used) + user_meta = await get_user_meta(runtime.store, "@alice:example.org") + assert user_meta["next_chat_index"] == 2 # Incremented from 1 to 2 +``` + +**File 2: tests/adapter/matrix/test_chat_space.py (MAT-04, MAT-05, MAT-10, MAT-12)** + +```python +from __future__ import annotations + +from types import SimpleNamespace +from unittest.mock import AsyncMock + +from nio.responses import RoomCreateError + +from adapter.matrix.handlers.chat import make_handle_new_chat, make_handle_archive +from adapter.matrix.store import set_user_meta +from core.protocol import IncomingCommand, OutgoingMessage +from core.store import InMemoryStore +from core.chat import ChatManager +from core.auth import AuthManager +from core.settings import SettingsManager +from sdk.mock import MockPlatformClient + + +async def _setup(): + """Helper: create platform, store, managers, authenticate user.""" + platform = MockPlatformClient() + store = InMemoryStore() + chat_mgr = ChatManager(platform, store) + auth_mgr = AuthManager(platform, store) + settings_mgr = SettingsManager(platform, store) + await auth_mgr.confirm("@alice:example.org") + return platform, store, chat_mgr, auth_mgr, settings_mgr + + +async def test_mat04_new_chat_calls_room_put_state_with_space_id(): + """MAT-04: !new calls room_put_state to add room to Space.""" + platform, store, chat_mgr, auth_mgr, settings_mgr = await _setup() + await set_user_meta(store, "@alice:example.org", {"space_id": "!space:ex", "next_chat_index": 2}) + + client = SimpleNamespace( + room_create=AsyncMock(return_value=SimpleNamespace(room_id="!newroom:ex")), + room_put_state=AsyncMock(), + room_invite=AsyncMock(), + ) + handler = make_handle_new_chat(client, store) + event = IncomingCommand( + user_id="@alice:example.org", platform="matrix", chat_id="C1", command="new", args=["Test"] + ) + result = await handler(event, auth_mgr, platform, chat_mgr, settings_mgr) + + client.room_put_state.assert_awaited_once() + ps_kwargs = client.room_put_state.call_args.kwargs + assert ps_kwargs.get("room_id") == "!space:ex" + assert ps_kwargs.get("event_type") == "m.space.child" + assert ps_kwargs.get("state_key") == "!newroom:ex" + assert any(isinstance(r, OutgoingMessage) and "Test" in r.text for r in result) + + +async def test_mat05_new_chat_without_space_id_returns_error(): + """MAT-05: !new without space_id in user_meta returns error message.""" + platform, store, chat_mgr, auth_mgr, settings_mgr = await _setup() + # user_meta exists but no space_id + await set_user_meta(store, "@alice:example.org", {"next_chat_index": 1}) + + client = SimpleNamespace( + room_create=AsyncMock(), + room_put_state=AsyncMock(), + room_invite=AsyncMock(), + ) + handler = make_handle_new_chat(client, store) + event = IncomingCommand( + user_id="@alice:example.org", platform="matrix", chat_id="C1", command="new" + ) + result = await handler(event, auth_mgr, platform, chat_mgr, settings_mgr) + + # Should return error, not crash + assert len(result) == 1 + assert isinstance(result[0], OutgoingMessage) + assert "Space" in result[0].text or "ошибка" in result[0].text.lower() or "Ошибка" in result[0].text + # room_create should NOT have been called + client.room_create.assert_not_awaited() + + +async def test_mat10_archive_calls_chat_mgr(): + """MAT-10: !archive archives via chat_mgr.""" + platform, store, chat_mgr, auth_mgr, settings_mgr = await _setup() + + handler = make_handle_archive(None, store) + event = IncomingCommand( + user_id="@alice:example.org", platform="matrix", chat_id="C1", command="archive" + ) + # Create a chat first so archive has something to work with + await chat_mgr.get_or_create( + user_id="@alice:example.org", chat_id="C1", platform="matrix", + surface_ref="!room:ex", name="Test" + ) + result = await handler(event, auth_mgr, platform, chat_mgr, settings_mgr) + + assert len(result) == 1 + assert "архивирован" in result[0].text + + +async def test_mat12_room_create_error_returns_user_message(): + """MAT-12: RoomCreateError is handled gracefully with user-facing message.""" + platform, store, chat_mgr, auth_mgr, settings_mgr = await _setup() + await set_user_meta(store, "@alice:example.org", {"space_id": "!space:ex", "next_chat_index": 2}) + + # Simulate RoomCreateError + error_resp = RoomCreateError(message="rate limited", status_code="429") + client = SimpleNamespace( + room_create=AsyncMock(return_value=error_resp), + room_put_state=AsyncMock(), + room_invite=AsyncMock(), + ) + handler = make_handle_new_chat(client, store) + event = IncomingCommand( + user_id="@alice:example.org", platform="matrix", chat_id="C1", command="new", args=["Fail"] + ) + result = await handler(event, auth_mgr, platform, chat_mgr, settings_mgr) + + assert len(result) == 1 + assert isinstance(result[0], OutgoingMessage) + assert "Не удалось" in result[0].text or "не удалось" in result[0].text + # room_put_state should NOT have been called (room creation failed) + client.room_put_state.assert_not_awaited() +``` + +NOTE: For MAT-12, `RoomCreateError` constructor signature may differ. Check the actual nio source. It might be `RoomCreateError(message="...", status_code="...")` or just `RoomCreateError(message="...")`. If the constructor fails, create a mock: +```python +error_resp = SimpleNamespace(status_code="429") # Duck-typing: no room_id attr +``` +and rely on `isinstance(resp, RoomCreateError)` check in the handler. If isinstance check is used, the SimpleNamespace won't match — so use the real class or mock it. Actually, the handler uses `isinstance(resp, RoomCreateError)` so we MUST use a real `RoomCreateError` instance or the check won't match. Try both approaches: +- First: `RoomCreateError(message="error")` +- If that fails: mock the isinstance check by making room_create return an object where `hasattr(resp, 'room_id')` is False + +Read `nio/responses.py` source to find the exact constructor if `RoomCreateError(message="error")` fails during test execution. + +**File 3: tests/adapter/matrix/test_send_outgoing.py (MAT-06, MAT-07)** + +```python +from __future__ import annotations + +from types import SimpleNamespace +from unittest.mock import AsyncMock + +from adapter.matrix.bot import send_outgoing +from adapter.matrix.store import get_pending_confirm +from core.protocol import OutgoingUI, UIButton +from core.store import InMemoryStore + + +async def test_mat06_outgoing_ui_renders_text_with_yes_no(): + """MAT-06: OutgoingUI renders as text + '!yes / !no' hint.""" + client = SimpleNamespace(room_send=AsyncMock()) + store = InMemoryStore() + event = OutgoingUI( + chat_id="C1", + text="Удалить файл?", + buttons=[UIButton(label="Подтвердить", action="confirm")], + ) + + await send_outgoing(client, "!room:ex", event, store=store) + + client.room_send.assert_awaited_once() + call_args = client.room_send.call_args + body = call_args.args[2]["body"] if len(call_args.args) > 2 else call_args.kwargs.get("content", {}).get("body", "") + assert "Удалить файл?" in body + assert "!yes" in body + assert "!no" in body + assert "Подтвердить" in body + + +async def test_mat07_outgoing_ui_no_reaction_sent(): + """MAT-07: OutgoingUI does NOT send m.reaction event.""" + client = SimpleNamespace(room_send=AsyncMock()) + store = InMemoryStore() + event = OutgoingUI( + chat_id="C1", + text="Confirm action?", + buttons=[UIButton(label="OK", action="confirm")], + ) + + await send_outgoing(client, "!room:ex", event, store=store) + + # Only one room_send call (the text message), no m.reaction + assert client.room_send.await_count == 1 + call_args = client.room_send.call_args + msg_type = call_args.args[1] if len(call_args.args) > 1 else "" + assert msg_type == "m.room.message" + # Verify no m.reaction calls + for call in client.room_send.call_args_list: + assert call.args[1] != "m.reaction" +``` + +**File 4: tests/adapter/matrix/test_confirm.py (MAT-09)** + +```python +from __future__ import annotations + +from adapter.matrix.handlers.confirm import make_handle_confirm, make_handle_cancel +from adapter.matrix.store import set_pending_confirm, get_pending_confirm +from core.protocol import IncomingCallback, OutgoingMessage +from core.store import InMemoryStore +from sdk.mock import MockPlatformClient +from core.chat import ChatManager +from core.auth import AuthManager +from core.settings import SettingsManager + + +async def test_mat09_yes_reads_pending_confirm(): + """MAT-09: !yes reads pending_confirm and returns action description.""" + store = InMemoryStore() + platform = MockPlatformClient() + chat_mgr = ChatManager(platform, store) + auth_mgr = AuthManager(platform, store) + settings_mgr = SettingsManager(platform, store) + + # Set up pending confirmation + await set_pending_confirm(store, "C1", { + "action_id": "delete_file", + "description": "Удалить файл config.yaml", + "payload": {}, + }) + + handler = make_handle_confirm(store) + event = IncomingCallback( + user_id="@alice:example.org", + platform="matrix", + chat_id="C1", + action="confirm", + payload={"source": "command", "command": "yes"}, + ) + result = await handler(event, auth_mgr, platform, chat_mgr, settings_mgr) + + assert len(result) == 1 + assert isinstance(result[0], OutgoingMessage) + assert "Удалить файл config.yaml" in result[0].text + + # pending_confirm should be cleared after confirmation + pending = await get_pending_confirm(store, "C1") + assert pending is None + + +async def test_no_clears_pending_confirm(): + """!no clears pending_confirm and returns cancellation.""" + store = InMemoryStore() + platform = MockPlatformClient() + chat_mgr = ChatManager(platform, store) + auth_mgr = AuthManager(platform, store) + settings_mgr = SettingsManager(platform, store) + + await set_pending_confirm(store, "C1", { + "action_id": "delete_file", + "description": "Удалить файл", + "payload": {}, + }) + + handler = make_handle_cancel(store) + event = IncomingCallback( + user_id="@alice:example.org", + platform="matrix", + chat_id="C1", + action="cancel", + payload={"source": "command", "command": "no"}, + ) + result = await handler(event, auth_mgr, platform, chat_mgr, settings_mgr) + + assert len(result) == 1 + assert "отменено" in result[0].text.lower() + + pending = await get_pending_confirm(store, "C1") + assert pending is None + + +async def test_yes_without_pending_returns_no_pending(): + """!yes with no pending confirmation returns 'no pending' message.""" + store = InMemoryStore() + platform = MockPlatformClient() + chat_mgr = ChatManager(platform, store) + auth_mgr = AuthManager(platform, store) + settings_mgr = SettingsManager(platform, store) + + handler = make_handle_confirm(store) + event = IncomingCallback( + user_id="@alice:example.org", + platform="matrix", + chat_id="C1", + action="confirm", + payload={}, + ) + result = await handler(event, auth_mgr, platform, chat_mgr, settings_mgr) + + assert len(result) == 1 + assert "Нет ожидающих" in result[0].text +``` + +**File 5: Extend tests/adapter/matrix/test_store.py (MAT-08)** + +Add at the end of the existing file: + +```python +async def test_pending_confirm_roundtrip(store: InMemoryStore): + """MAT-08: get/set/clear_pending_confirm roundtrip.""" + from adapter.matrix.store import get_pending_confirm, set_pending_confirm, clear_pending_confirm + + # Initially None + assert await get_pending_confirm(store, "!room:m.org") is None + + # Set + meta = {"action_id": "test", "description": "Do thing"} + await set_pending_confirm(store, "!room:m.org", meta) + assert await get_pending_confirm(store, "!room:m.org") == meta + + # Clear + await clear_pending_confirm(store, "!room:m.org") + assert await get_pending_confirm(store, "!room:m.org") is None +``` + +**File 6: Extend tests/adapter/matrix/test_dispatcher.py (MAT-11)** + +Add at the end of test_dispatcher.py: + +```python +async def test_mat11_settings_returns_dashboard(): + """MAT-11: !settings returns a read-only dashboard with status info.""" + runtime = build_runtime(platform=MockPlatformClient()) + + # Authenticate user first + start = IncomingCommand(user_id="u1", platform="matrix", chat_id="C1", command="start") + await runtime.dispatcher.dispatch(start) + + settings_cmd = IncomingCommand(user_id="u1", platform="matrix", chat_id="C1", command="settings") + result = await runtime.dispatcher.dispatch(settings_cmd) + + assert len(result) >= 1 + text = result[0].text + # Dashboard should contain section headers + assert "Скиллы" in text or "скиллы" in text.lower() + assert "Изменить" in text or "!skills" in text + # Should NOT be the old command list format + assert "!connectors" not in text + assert "!whoami" not in text +``` + +IMPORTANT: Check that `core/store.py` InMemoryStore has a `delete` method. If it does NOT, the `clear_pending_confirm` function will fail. Read `core/store.py` and if `delete` is missing, implement `clear_pending_confirm` using `store.set(key, None)` instead and update the test accordingly. + + + cd /Users/a/MAI/sem2/lambda/surfaces-bot && pytest tests/adapter/matrix/ -x -q 2>&1 | tail -10 + + +- File `tests/adapter/matrix/test_invite_space.py` exists and contains `test_mat01`, `test_mat02`, `test_mat03` +- File `tests/adapter/matrix/test_chat_space.py` exists and contains `test_mat04`, `test_mat05`, `test_mat10`, `test_mat12` +- File `tests/adapter/matrix/test_send_outgoing.py` exists and contains `test_mat06`, `test_mat07` +- File `tests/adapter/matrix/test_confirm.py` exists and contains `test_mat09` +- `tests/adapter/matrix/test_store.py` contains `test_pending_confirm_roundtrip` +- `tests/adapter/matrix/test_dispatcher.py` contains `test_mat11_settings_returns_dashboard` +- `pytest tests/adapter/matrix/ -x -q` passes with 0 failures +- `pytest tests/ -q` shows 96+ tests passing + + All 12 new tests (MAT-01..MAT-12) implemented and green; 4 broken tests fixed; total 96+ passing + + + + + +After both tasks: +- `pytest tests/ -q` shows 96+ tests passing, 0 failures +- `pytest tests/adapter/matrix/ -q` shows all Matrix tests passing +- New test files exist: test_invite_space.py, test_chat_space.py, test_send_outgoing.py, test_confirm.py + + + +- 96+ tests passing in full suite +- 4 broken tests fixed (renamed/updated for Space model) +- 12 new tests implemented covering MAT-01..MAT-12 +- No test references hardcoded "C1" from old DM flow +- All test files importable and runnable + + + +After completion, create `.planning/phases/01-matrix-qa-polish/01-04-SUMMARY.md` +