Upload 12 files

bot.py

@@ -0,0 +1,187 @@
+import asyncio
+import logging
+import os
+import ssl
+import sys
+
+import aiohttp
+import certifi
+from aiohttp import web
+from aiogram import Bot, Dispatcher
+from aiogram.enums import ParseMode
+from aiogram.webhook.aiohttp_server import SimpleRequestHandler, setup_application
+
+from config import config
+from database import db
+from handlers import commands_router, chat_router
+from middlewares import OwnerMiddleware
+
+
+# ═══════════════════════════════════════════════════════════════════
+# BLOCK 0: SSL-патчи для HF Spaces (certifi + proxy)
+# ═══════════════════════════════════════════════════════════════════
+# HF Spaces не имеет системных CA-сертификатов.
+# Патчи применяются как side-effect при импорте.
+# ═══════════════════════════════════════════════════════════════════
+
+custom_ssl = ssl.create_default_context(cafile=certifi.where())
+custom_ssl.check_hostname = True
+custom_ssl.verify_mode = ssl.CERT_REQUIRED
+
+_orig_tcp_init = aiohttp.TCPConnector.__init__
+
+
+def _patched_tcp_init(self, *args, **kwargs):
+    if kwargs.get("ssl") is not False:
+        kwargs["ssl"] = custom_ssl
+    _orig_tcp_init(self, *args, **kwargs)
+
+
+aiohttp.TCPConnector.__init__ = _patched_tcp_init
+
+_orig_session_init = aiohttp.ClientSession.__init__
+
+
+def _patched_session_init(self, *args, **kwargs):
+    kwargs["trust_env"] = True
+    _orig_session_init(self, *args, **kwargs)
+
+
+aiohttp.ClientSession.__init__ = _patched_session_init
+
+_orig_request = aiohttp.ClientSession._request
+
+
+async def _patched_request(self, method, url, *args, **kwargs):
+    proxy_server = os.getenv("TELEGRAM_API_SERVER")
+    if proxy_server and "api.telegram.org" in str(url):
+        proxy_server = proxy_server.strip().rstrip("/")
+        str_url = str(url).replace("https://api.telegram.org", proxy_server)
+        logging.info("🔀 Переадресация aiogram через прокси ➡️ %s", str_url)
+        url = str_url
+    return await _orig_request(self, method, url, *args, **kwargs)
+
+
+aiohttp.ClientSession._request = _patched_request
+
+
+# ═══════════════════════════════════════════════════════════════════
+# BLOCK 1: Логирование
+# ═══════════════════════════════════════════════════════════════════
+
+def setup_logging() -> None:
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        stream=sys.stdout,
+    )
+
+
+# ═══════════════════════════════════════════════════════════════════
+# BLOCK 2: Инициализация бота и диспетчера
+# ═══════════════════════════════════════════════════════════════════
+
+bot = Bot(token=config.BOT_TOKEN, parse_mode=ParseMode.HTML)
+dp = Dispatcher()
+
+dp.message.middleware(OwnerMiddleware())
+dp.include_router(commands_router)
+dp.include_router(chat_router)
+
+
+# ═══════════════════════════════════════════════════════════════════
+# BLOCK 3: HTTP Handlers
+# ═══════════════════════════════════════════════════════════════════
+
+@web.middleware
+async def hf_logging_middleware(request, handler):
+    return await handler(request)
+
+
+async def health_check(request: web.Request) -> web.Response:
+    """HF Spaces Health Check — обязательно отвечать 200 на '/'."""
+    return web.Response(text="🚀 GLM Bot РАБОТАЕТ!")
+
+
+# ═══════════════════════════════════════════════════════════════════
+# BLOCK 4: Lifecycle hooks
+# ═══════════════════════════════════════════════════════════════════
+
+async def on_startup(app: web.Application) -> None:
+    logger = logging.getLogger(__name__)
+    await db.connect()
+    logger.info("Database connected")
+
+    space_host = config.SPACE_HOST or os.getenv("SPACE_HOST", "")
+    if space_host:
+        full_webhook_link = f"https://{space_host.strip()}{config.WEBHOOK_PATH}"
+        for attempt in range(5):
+            try:
+                await bot.set_webhook(
+                    url=full_webhook_link,
+                    drop_pending_updates=True,
+                    request_timeout=30,
+                )
+                logger.info("✅ Webhook установлен: %s", full_webhook_link)
+                break
+            except Exception as e:
+                logger.warning(
+                    "⚠️ Попытка %d/5 установки webhook: %s", attempt + 1, e
+                )
+                await asyncio.sleep(5)
+    else:
+        logger.warning("⚠️ SPACE_HOST не задан, webhook не установлен!")
+
+
+async def on_shutdown(app: web.Application) -> None:
+    logger = logging.getLogger(__name__)
+    logger.info("🛑 Shutdown начат...")
+
+    try:
+        await bot.delete_webhook(drop_pending_updates=True)
+        logger.info("Webhook удалён")
+    except Exception as e:
+        logger.warning("Ошибка при удалении webhook: %s", e)
+
+    try:
+        await dp.storage.close()
+        await bot.session.close()
+        logger.info("Bot session закрыт")
+    except Exception as e:
+        logger.warning("Ошибка при закрытии сессии бота: %s", e)
+
+    try:
+        await db.disconnect()
+        logger.info("Database disconnected")
+    except Exception as e:
+        logger.warning("Ошибка при отключении БД: %s", e)
+
+
+# ═══════════════════════════════════════════════════════════════════
+# BLOCK 5: Main
+# ═══════════════════════════════════════════════════════════════════
+
+def main() -> None:
+    setup_logging()
+    logger = logging.getLogger(__name__)
+    logger.info("Starting HF Spaces bot...")
+
+    app = web.Application(middlewares=[hf_logging_middleware])
+    app.router.add_get("/", health_check)
+
+    webhook_requests_handler = SimpleRequestHandler(dispatcher=dp, bot=bot)
+    webhook_requests_handler.register(app, path=config.WEBHOOK_PATH)
+    setup_application(app, dp, bot=bot)
+
+    app.on_startup.append(on_startup)
+    app.on_shutdown.append(on_shutdown)
+
+    # HF Spaces требует: host='0.0.0.0', port=7860
+    port = int(os.environ.get("PORT", 7860))
+    logger.info("🚀 Запуск сервера на %s:%d...", "0.0.0.0", port)
+    web.run_app(app, host="0.0.0.0", port=port)
+
+
+if __name__ == "__main__":
+    main()
+

config.py

@@ -0,0 +1,48 @@
+import os
+from dataclasses import dataclass
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+@dataclass
+class Config:
+    BOT_TOKEN: str = os.getenv("BOT_TOKEN", "")
+    OWNER_ID: int = int(os.getenv("OWNER_ID", "0") or "0")
+    DATABASE_URL: str = os.getenv("DATABASE_URL", "")
+    NVIDIA_API_KEY: str = os.getenv("NVIDIA_API_KEY", "")
+    NVIDIA_BASE_URL: str = "https://integrate.api.nvidia.com/v1"
+    MODEL_NAME: str = "z-ai/glm-5.1"
+    MAX_HISTORY: int = 30
+    MAX_MESSAGE_LENGTH: int = 4096
+    SUMMARIZE_THRESHOLD: int = 30  # Суммаризировать когда сообщений > N
+    SUMMARY_MAX_TOKENS: int = 512
+    GLM_TEMPERATURE: float = 0.8
+    GLM_TOP_P: float = 0.95
+    GLM_FREQUENCY_PENALTY: float = 0.2
+    GLM_PRESENCE_PENALTY: float = 0.1
+    GLM_MAX_TOKENS: int = 8192
+    WEBHOOK_PATH: str = "/webhook"
+    SPACE_HOST: str = os.getenv("SPACE_HOST", "")
+
+    def __post_init__(self) -> None:
+        # Neon and some providers use postgres:// which asyncpg does not accept
+        if self.DATABASE_URL.startswith("postgres://"):
+            self.DATABASE_URL = self.DATABASE_URL.replace(
+                "postgres://", "postgresql://", 1
+            )
+
+    def validate(self) -> None:
+        if not self.BOT_TOKEN:
+            raise ValueError("BOT_TOKEN is required")
+        if not self.OWNER_ID:
+            raise ValueError("OWNER_ID is required")
+        if not self.DATABASE_URL:
+            raise ValueError("DATABASE_URL is required")
+        if not self.NVIDIA_API_KEY:
+            raise ValueError("NVIDIA_API_KEY is required")
+
+
+config = Config()
+config.validate()
+

database.py

@@ -0,0 +1,192 @@
+import asyncpg
+import logging
+from typing import Optional, List, Dict, Any
+from config import config
+
+logger = logging.getLogger(__name__)
+
+
+class Database:
+    def __init__(self) -> None:
+        self.pool: Optional[asyncpg.Pool] = None
+
+    async def connect(self) -> None:
+        # Render free tier: 512 MB RAM, keep pool small
+        self.pool = await asyncpg.create_pool(
+            dsn=config.DATABASE_URL,
+            min_size=1,
+            max_size=3,
+            command_timeout=60,
+        )
+        logger.info("Database pool created (max_size=3)")
+        await self._create_tables()
+
+    async def disconnect(self) -> None:
+        if self.pool:
+            await self.pool.close()
+            logger.info("Database pool closed")
+
+    def _acquire(self):
+        if self.pool is None:
+            raise RuntimeError("Database not connected. Call connect() first.")
+        return self.pool.acquire()
+
+    async def _create_tables(self) -> None:
+        async with self._acquire() as conn:
+            await conn.execute("""
+                CREATE TABLE IF NOT EXISTS users (
+                    id BIGINT PRIMARY KEY,
+                    username VARCHAR(255),
+                    first_name VARCHAR(255),
+                    last_name VARCHAR(255),
+                    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+                    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+                )
+            """)
+              await conn.execute("""
+                CREATE TABLE IF NOT EXISTS messages (
+                    id SERIAL PRIMARY KEY,
+                    user_id BIGINT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+                    role VARCHAR(20) NOT NULL CHECK (role IN ('user', 'assistant', 'system')),
+                    content TEXT NOT NULL,
+                    is_summarized BOOLEAN DEFAULT FALSE,
+                    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+                )
+            """)
+            await conn.execute("""
+                CREATE INDEX IF NOT EXISTS idx_messages_user_id_created_at
+                ON messages(user_id, created_at DESC)
+            """)
+            await conn.execute("""
+                CREATE INDEX IF NOT EXISTS idx_messages_user_id_summarized
+                ON messages(user_id, is_summarized, created_at DESC)
+            """)
+            await conn.execute("""
+                CREATE TABLE IF NOT EXISTS summaries (
+                    id SERIAL PRIMARY KEY,
+                    user_id BIGINT NOT NULL UNIQUE REFERENCES users(id) ON DELETE CASCADE,
+                    summary TEXT NOT NULL,
+                    message_count INTEGER NOT NULL DEFAULT 0,
+                    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+                    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+                )
+            """)
+
+            logger.info("Database tables created/verified")
+
+    async def upsert_user(
+        self,
+        user_id: int,
+        username: Optional[str],
+        first_name: Optional[str],
+        last_name: Optional[str],
+    ) -> None:
+        async with self._acquire() as conn:
+            await conn.execute("""
+                INSERT INTO users (id, username, first_name, last_name)
+                VALUES ($1, $2, $3, $4)
+                ON CONFLICT (id) DO UPDATE SET
+                    username = EXCLUDED.username,
+                    first_name = EXCLUDED.first_name,
+                    last_name = EXCLUDED.last_name,
+                    updated_at = NOW()
+            """, user_id, username, first_name, last_name)
+
+    async def save_message(self, user_id: int, role: str, content: str) -> None:
+        async with self._acquire() as conn:
+            await conn.execute("""
+                INSERT INTO messages (user_id, role, content)
+                VALUES ($1, $2, $3)
+            """, user_id, role, content)
+
+    async def get_messages(self, user_id: int, limit: int = 30) -> List[Dict[str, Any]]:
+        async with self._acquire() as conn:
+            rows = await conn.fetch("""
+                SELECT role, content, created_at
+                FROM messages
+                WHERE user_id = $1 AND is_summarized = FALSE
+                ORDER BY created_at DESC
+                LIMIT $2
+            """, user_id, limit)
+            # Reverse to chronological order for the LLM
+            return [
+                {"role": r["role"], "content": r["content"], "created_at": r["created_at"]}
+                for r in reversed(rows)
+            ]
+
+    async def get_summary(self, user_id: int) -> Optional[str]:
+        async with self._acquire() as conn:
+            row = await conn.fetchrow("""
+                SELECT summary FROM summaries WHERE user_id = $1
+            """, user_id)
+            return row["summary"] if row else None
+
+    async def save_summary(self, user_id: int, summary: str, message_count: int) -> None:
+        async with self._acquire() as conn:
+            await conn.execute("""
+                INSERT INTO summaries (user_id, summary, message_count, updated_at)
+                VALUES ($1, $2, $3, NOW())
+                ON CONFLICT (user_id) DO UPDATE SET
+                    summary = EXCLUDED.summary,
+                    message_count = summaries.message_count + EXCLUDED.message_count,
+                    updated_at = NOW()
+            """, user_id, summary, message_count)
+
+    async def mark_summarized(self, user_id: int, cutoff_id: int) -> None:
+        async with self._acquire() as conn:
+            await conn.execute("""
+                UPDATE messages
+                SET is_summarized = TRUE
+                WHERE user_id = $1 AND id <= $2
+            """, user_id, cutoff_id)
+
+    async def get_oldest_unsummarized(self, user_id: int, limit: int) -> List[Dict[str, Any]]:
+        async with self._acquire() as conn:
+            rows = await conn.fetch("""
+                SELECT id, role, content
+                FROM messages
+                WHERE user_id = $1 AND is_summarized = FALSE
+                ORDER BY created_at ASC
+                LIMIT $2
+            """, user_id, limit)
+            return [{"id": r["id"], "role": r["role"], "content": r["content"]} for r in rows]
+
+    async def count_unsummarized(self, user_id: int) -> int:
+        async with self._acquire() as conn:
+            return await conn.fetchval("""
+                SELECT COUNT(*) FROM messages
+                WHERE user_id = $1 AND is_summarized = FALSE
+            """, user_id) or 0
+
+    async def clear_history(self, user_id: int) -> int:
+        async with self._acquire() as conn:
+            result = await conn.execute("""
+                DELETE FROM messages WHERE user_id = $1
+            """, user_id)
+            await conn.execute("""
+                DELETE FROM summaries WHERE user_id = $1
+            """, user_id)
+            try:
+                count = int(result.split()[-1])
+            except (ValueError, IndexError):
+                count = 0
+            logger.info("Cleared %d messages and summary for user %s", count, user_id)
+            return count
+
+
+    async def get_stats(self, user_id: int) -> Dict[str, Any]:
+        async with self._acquire() as conn:
+            user_count = await conn.fetchval("SELECT COUNT(*) FROM users")
+            msg_count = await conn.fetchval(
+                "SELECT COUNT(*) FROM messages WHERE user_id = $1", user_id
+            )
+            total_msg_count = await conn.fetchval("SELECT COUNT(*) FROM messages")
+            return {
+                "total_users": user_count,
+                "user_messages": msg_count,
+                "total_messages": total_msg_count,
+            }
+
+
+db = Database()
+

handlers __init__.py

@@ -0,0 +1,2 @@
+from .commands import router as commands_router
+from .chat import router as chat_router

handlers chat.py

@@ -0,0 +1,435 @@
+import asyncio
+import logging
+from aiogram import Router, types
+from aiogram.exceptions import TelegramAPIError
+from config import config
+from database import db
+from services.glm import glm_service
+from utils.helpers import send_long_message
+
+logger = logging.getLogger(__name__)
+router = Router()
+
+SYSTEM_PROMPT = {
+    "role": "system",
+    "content": (
+        "ТЫ РАБОТАЕШЬ КАК SENIOR STAFF PYTHON ENGINEER И ACTING CTO.\n\n"
+        "ТЫ РАЗРАБАТЫВАЕШЬ PRODUCTION TELEGRAM AI SAAS.\n\n"
+        "ТВОЯ ГЛАВНАЯ ЗАДАЧА:\n\n"
+        "Реализовывать новые функции, исправлять баги и развивать архитектуру без нарушения существующей бизнес-логики.\n\n"
+        "============================================================\n"
+        "ДОЛГОВРЕМЕННАЯ ПАМЯТЬ И КОНТЕКСТ\n"
+        "============================================================\n\n"
+        "У тебя есть доступ к долговременной памяти через Neon PostgreSQL.\n"
+        "Ты получаешь два источника контекста:\n"
+        "1. [Контекст предыдущих диалогов] — суммаризированная история старых разговоров.\n"
+        "2. Последние сообщения текущего диалога — непосредственная история.\n\n"
+        "Правила работы с памятью:\n"
+        "- Используй summary для понимания долгосрочных предпочтений пользователя, его проекта, стека технологий.\n"
+        "- Ссылайся на предыдущие решения и обсуждения, если они релевантны текущему запросу.\n"
+        "- Не повторяй информацию из summary, если пользователь уже знает её.\n"
+        "- Если пользователь просит продолжить работу — используй контекст для восстановления состояния.\n"
+        "- Помни: история сохраняется между сессиями. Бот перезапускается, но память остаётся.\n\n"
+        "============================================================\n"
+        "ОБЯЗАТЕЛЬНЫЙ ПРОЦЕСС РАБОТЫ\n"
+        "============================================================\n\n"
+        "Перед написанием кода всегда выполняй:\n\n"
+        "1. Анализ задачи.\n"
+        "2. Анализ архитектуры.\n"
+        "3. Поиск точки интеграции.\n"
+        "4. Поиск зависимостей.\n"
+        "5. Анализ побочных эффектов.\n"
+        "6. Только после этого предлагай изменения.\n\n"
+        "Никогда не начинай писать код сразу.\n\n"
+        "============================================================\n"
+        "КРИТИЧЕСКИЕ ЗАПРЕТЫ\n"
+        "============================================================\n\n"
+        "Запрещено:\n\n"
+        "- ломать существующую архитектуру;\n"
+        "- удалять существующую бизнес-логику;\n"
+        "- менять FSM без необходимости;\n"
+        "- менять маршрутизацию бота без необходимости;\n"
+        "- менять структуру БД без необходимости;\n"
+        "- менять OpenAI-интеграцию без необходимости;\n"
+        "- менять существующие API без необходимости;\n"
+        "- менять рабочий код ради рефакторинга.\n\n"
+        "Если код уже работает:\n\n"
+        "СОХРАНИТЬ ЕГО.\n\n"
+        "Менять только то, что требуется задачей.\n\n"
+        "============================================================\n"
+        "ПРИНЦИП МИНИМАЛЬНЫХ ИЗМЕНЕНИЙ\n"
+        "============================================================\n\n"
+        "Предпочитать:\n\n"
+        "- локальные патчи;\n"
+        "- локальные функции;\n"
+        "- локальные классы;\n"
+        "- локальные интеграции.\n\n"
+        "Не переписывать большие блоки ради маленькой задачи.\n\n"
+        "============================================================\n"
+        "ПРАВИЛО БОЛЬШИХ ФАЙЛОВ\n"
+        "============================================================\n\n"
+        "Файл может содержать:\n\n"
+        "5000+\n"
+        "7000+\n"
+        "10000+ строк.\n\n"
+        "Если изменение можно выполнить локально:\n\n"
+        "НЕ ВЫВОДИТЬ ВЕСЬ БЛОК.\n\n"
+        "НЕ ВЫВОДИТЬ ВЕСЬ ФАЙЛ.\n\n"
+        "НЕ ВЫВОДИТЬ ВЕСЬ КЛАСС.\n\n"
+        "Использовать PATCH MODE.\n\n"
+        "============================================================\n"
+        "PATCH MODE\n"
+        "============================================================\n\n"
+        "Если блок больше 200 строк:\n\n"
+        "НЕ ВЫВОДИТЬ ЕГО ПОЛНОСТЬЮ.\n\n"
+        "Вместо этого показывать:\n\n"
+        "PATCH 1/N\n\n"
+        "БЛОК:\n"
+        "ПОДБЛОК:\n\n"
+        "НАЙТИ:\n\n"
+        "<существующий код>\n\n"
+        "ДОБАВИТЬ ПОСЛЕ:\n\n"
+        "<новый код>\n\n"
+        "или\n\n"
+        "ЗАМЕНИТЬ:\n\n"
+        "<старый код>\n\n"
+        "НА:\n\n"
+        "<новый код>\n\n"
+        "Каждый патч должен быть независимым.\n\n"
+        "Каждый патч должен копироваться отдельно.\n\n"
+        "Размер одного патча желательно не более 150 строк.\n\n"
+        "============================================================\n"
+        "ГРАНИЦЫ БЛОКОВ\n"
+        "============================================================\n\n"
+        "Если в проекте существуют блоки вида:\n\n"
+        "# ============================================================\n"
+        "# BLOCK X\n"
+        "# ============================================================\n\n"
+        "или\n\n"
+        "# SUBBLOCK X.X\n\n"
+        "использовать их как ориентиры.\n\n"
+        "Всегда указывать:\n\n"
+        "БЛОК:\n"
+        "ПОДБЛОК:\n\n"
+        "для каждого изменения.\n\n"
+        "============================================================\n"
+        "ТРЕБОВАНИЯ К КОДУ\n"
+        "============================================================\n\n"
+        "Код должен быть:\n\n"
+        "- Production Ready;\n"
+        "- Python 3.11+;\n"
+        "- Async Safe;\n"
+        "- Thread Safe;\n"
+        "- читаемым;\n"
+        "- масштабируемым;\n"
+        "- совместимым с существующим проектом.\n\n"
+        "============================================================\n"
+        "ЗАПРЕЩЕНО В КОДЕ\n"
+        "============================================================\n\n"
+        "Запрещено:\n\n"
+        "TODO\n\n"
+        "FIXME\n\n"
+        "PLACEHOLDER\n\n"
+        "PASS\n\n"
+        "ваша логика здесь\n\n"
+        "псевдокод\n\n"
+        "сокращённые реализации\n\n"
+        "незавершённые функции\n\n"
+        "============================================================\n"
+        "ПОЛНОТА КОДА\n"
+        "============================================================\n\n"
+        "Если изменяется функция:\n\n"
+        "выводить функцию полностью.\n\n"
+        "Если изменяется класс:\n\n"
+        "выводить класс полностью.\n\n"
+        "Если изменяется маленький блок:\n\n"
+        "выводить блок полностью.\n\n"
+        "Если изменяется большой блок:\n\n"
+        "использовать PATCH MODE.\n\n"
+        "============================================================\n"
+        "БЕЗОПАСНОСТЬ\n"
+        "============================================================\n\n"
+        "Проверять:\n\n"
+        "- SQL Injection\n"
+        "- Prompt Injection\n"
+        "- Race Conditions\n"
+        "- Deadlocks\n"
+        "- Resource Leaks\n"
+        "- Memory Leaks\n"
+        "- Invalid User Input\n"
+        "- Unsafe Async Usage\n\n"
+        "============================================================\n"
+        "ПРОВЕРКА ПЕРЕД ОТВЕТОМ\n"
+        "============================================================\n\n"
+        "Перед выдачей решения проверить:\n\n"
+        "1. Не ломает ли решение текущую логику.\n"
+        "2. Не дублирует ли код.\n"
+        "3. Не создаёт ли новые зависимости.\n"
+        "4. Не нарушает ли архитектуру.\n"
+        "5. Не требует ли замены большого блока вместо локального патча.\n\n"
+        "============================================================\n"
+        "ФОРМАТ ОТВЕТА\n"
+        "============================================================\n\n"
+        "ВСЕГДА:\n\n"
+        "1. Анализ.\n"
+        "2. Что будет изменено.\n"
+        "3. Возможные риски.\n"
+        "4. PATCHES.\n"
+        "5. Инструкция по вставке.\n\n"
+        "Отвечай только на русском языке.\n\n"
+        "Никогда не сокращай код.\n"
+        "Никогда не пропускай важные части реализации.\n"
+        "Никогда не используй псевдокод.\n\n"
+        "============================================================\n"
+        "МЕЖМОДУЛЬНЫЙ АНАЛИЗ\n"
+        "============================================================\n\n"
+        "Перед изменением определить:\n\n"
+        "ПРЯМЫЕ ЗАВИСИМОСТИ:\n"
+        "- кто вызывает код\n\n"
+        "ОБРАТНЫЕ ЗАВИСИМОСТИ:\n"
+        "- кого вызывает код\n\n"
+        "ИМПОРТЫ:\n"
+        "- кто импортирует сущность\n\n"
+        "СВЯЗИ:\n"
+        "- БД\n"
+        "- FSM\n"
+        "- AI\n"
+        "- Memory\n"
+        "- Cache\n"
+        "- Middleware\n"
+        "- Scheduler\n"
+        "- Background Tasks\n\n"
+        "Вывести:\n\n"
+        "ЗАТРОНУТЫЕ ФАЙЛЫ\n\n"
+        "ПОТЕНЦИАЛЬНОЕ ВЛИЯНИЕ\n\n"
+        "УРОВЕНЬ РИСКА:\n\n"
+        "LOW\n"
+        "MEDIUM\n"
+        "HIGH\n"
+        "============================================================\n"
+        "РЕЖИМ НЕПОЛНОГО КОНТЕКСТА\n"
+        "============================================================\n\n"
+        "Если предоставлен не весь проект:\n\n"
+        "НЕ ДЕЛАТЬ ПРЕДПОЛОЖЕНИЙ.\n\n"
+        "НЕ ВЫДУМЫВАТЬ:\n\n"
+        "- существующие классы;\n"
+        "- существующие функции;\n"
+        "- существующие файлы;\n"
+        "- существующие импорты.\n\n"
+        "Если для безопасной реализации не хватает контекста:\n\n"
+        "УКАЗАТЬ:\n\n"
+        "ТРЕБУЕТСЯ ФАЙЛ:\n\n"
+        "- path/to/file.py\n\n"
+        "ПРИЧИНА:\n\n"
+        "Для проверки зависимостей и безопасной интеграции.\n\n"
+        "============================================================\n"
+        "ЗАЩИТА ОТ ГАЛЛЮЦИНАЦИЙ\n"
+        "============================================================\n\n"
+        "Запрещено:\n\n"
+        "- придумывать существующие методы;\n"
+        "- придумывать существующие классы;\n"
+        "- придумывать существующие таблицы БД;\n"
+        "- придумывать существующие поля БД;\n"
+        "- придумывать существующие API.\n\n"
+        "Если сущность не показана в предоставленном коде:\n\n"
+        "считать её неизвестной.\n\n"
+        "При необходимости запросить дополнительный код.\n"
+        "============================================================\n"
+        "ПРАВИЛО EXISTING IMPLEMENTATION FIRST\n"
+        "============================================================\n\n"
+        "Перед реализацией любой функции обязательно проверить:\n\n"
+        "1. Существует ли уже похожая реализация.\n"
+        "2. Существует ли частичная реализация.\n"
+        "3. Существует ли незавершённая реализация.\n"
+        "4. Существует ли старый код, который можно расширить.\n\n"
+        "Запрещено создавать:\n\n"
+        "- второй MemoryManager;\n"
+        "- второй AI Service;\n"
+        "- второй Repository;\n"
+        "- второй FSM Flow;\n"
+        "- второй Cache Layer;\n"
+        "- второй RAG Layer.\n\n"
+        "Если функциональность уже существует:\n\n"
+        "РАСШИРЯТЬ СУЩЕСТВУЮЩУЮ.\n\n"
+        "Не создавать дубликаты.\n"
+        "============================================================\n"
+        "РАБОТА ПО ФАЗАМ ПРОЕКТА\n"
+        "============================================================\n\n"
+        "Проект развивается по фазам.\n\n"
+        "Перед началом работы определить:\n\n"
+        "ТЕКУЩАЯ ФАЗА:\n"
+        "- B1\n"
+        "- B2\n"
+        "- B3\n"
+        "- B4\n"
+        "- B5\n"
+        "- B6\n"
+        "- B7\n"
+        "- C1\n"
+        "- C2\n"
+        "- и т.д.\n\n"
+        "Для каждой задачи определить:\n\n"
+        "1. Что уже реализовано.\n"
+        "2. Что закрыто.\n"
+        "3. Что находится в работе.\n"
+        "4. Что запрещено менять.\n\n"
+        "Запрещено:\n\n"
+        "- повторно реализовывать завершённые фазы;\n"
+        "- удалять код завершённых фаз;\n"
+        "- изменять код завершённых фаз без необходимости.\n\n"
+        "Если реализация относится к другой фазе:\n\n"
+        "СНАЧАЛА сообщить об этом.\n"
+        "============================================================\n"
+        "ПРЕДВАРИТЕЛЬНЫЙ АУДИТ\n"
+        "============================================================\n\n"
+        "Перед выдачей патча выполнить аудит:\n\n"
+        "- архитектуры;\n"
+        "- зависимостей;\n"
+        "- интеграций;\n"
+        "- БД;\n"
+        "- памяти;\n"
+        "- AI слоя;\n"
+        "- FSM;\n"
+        "- middleware;\n"
+        "- rate limits;\n"
+        "- кеширования.\n\n"
+        "Сначала вывести:\n\n"
+        "ROOT CAUSE\n\n"
+        "Затем:\n\n"
+        "АРХИТЕКТУРНОЕ РЕШЕНИЕ\n\n"
+        "И только потом патчи.\n"
+        "============================================================\n"
+        "МОНОЛИТНЫЕ ФАЙЛЫ\n"
+        "============================================================\n\n"
+        "Если файл больше 2000 строк:\n\n"
+        "Сначала определить:\n\n"
+        "- BLOCK\n"
+        "- SUBBLOCK\n\n"
+        "Запрещено:\n\n"
+        "- переписывать файл полностью;\n"
+        "- делать рефакторинг всего файла;\n"
+        "- менять порядок блоков.\n\n"
+        "Разрешено:\n\n"
+        "- локальные вставки;\n"
+        "- локальные замены;\n"
+        "- локальные фиксы.\n\n"
+        "Всегда сохранять существующую структуру.\n"
+        "============================================================\n"
+        "ПОИСК ТОЧКИ ИНТЕГРАЦИИ\n"
+        "============================================================\n\n"
+        "Перед написанием нового кода определить:\n\n"
+        "1. Где должна находиться реализация.\n"
+        "2. Какой существующий блок отвечает за данную функцию.\n"
+        "3. Можно ли встроить решение в существующий код.\n\n"
+        "Запрещено создавать новый модуль, если задача решается внутри существующего.\n\n"
+        "Сначала искать точку интеграции.\n\n"
+        "Потом писать код."
+    )
+}
+
+
+async def _maybe_summarize(user_id: int) -> None:
+    """Фоновая суммаризация старой истории."""
+    try:
+        count = await db.count_unsummarized(user_id)
+        threshold = config.SUMMARIZE_THRESHOLD
+        keep_recent = 10
+
+        if count <= threshold:
+            return
+
+        to_summarize = count - keep_recent
+        if to_summarize < 5:
+            return
+
+        old_messages = await db.get_oldest_unsummarized(user_id, to_summarize)
+        if len(old_messages) < 5:
+            return
+
+        dialog_text = "\n".join([
+            f"{m['role']}: {m['content']}" for m in old_messages
+        ])
+
+        summary = await glm_service.summarize(dialog_text)
+        if not summary:
+            return
+
+        cutoff_id = old_messages[-1]["id"]
+        await db.save_summary(user_id, summary, len(old_messages))
+        await db.mark_summarized(user_id, cutoff_id)
+
+        logger.info(
+            "Summarized %d messages for user %s, cutoff_id=%s",
+            len(old_messages), user_id, cutoff_id
+        )
+    except Exception as e:
+        logger.error("Summarization failed for user %s: %s", user_id, e, exc_info=True)
+
+
+@router.message()
+async def handle_chat(message: types.Message) -> None:
+    if not message.text:
+        await message.answer("❌ Поддерживаются только текстовые сообщения.")
+        return
+
+    user_id = message.from_user.id
+    user_text = message.text
+
+    # Save/update user
+    await db.upsert_user(
+        user_id=user_id,
+        username=message.from_user.username,
+        first_name=message.from_user.first_name,
+        last_name=message.from_user.last_name,
+    )
+
+    # Save user message
+    await db.save_message(user_id, "user", user_text)
+
+    # Get history (unsummarized only)
+    history = await db.get_messages(user_id, limit=config.MAX_HISTORY)
+
+    # Build messages for GLM
+    messages: list[dict] = [SYSTEM_PROMPT]
+
+    # Add summary as context if exists
+    summary = await db.get_summary(user_id)
+    if summary:
+        messages.append({
+            "role": "system",
+            "content": f"[Контекст предыдущих диалогов: {summary}]"
+        })
+
+    # Add recent conversation history
+    for h in history:
+        messages.append({"role": h["role"], "content": h["content"]})
+
+    # Add current user message (already saved in DB, but need it in the prompt)
+    if not history or history[-1]["content"] != user_text:
+        messages.append({"role": "user", "content": user_text})
+
+    # Send typing action
+    try:
+        await message.bot.send_chat_action(user_id, "typing")
+    except TelegramAPIError as e:
+        logger.warning("Failed to send typing action: %s", e)
+
+    try:
+        # Call GLM
+        response = await glm_service.chat(messages)
+
+        # Save assistant response
+        await db.save_message(user_id, "assistant", response)
+
+        # Trigger background summarization
+        asyncio.create_task(_maybe_summarize(user_id))
+
+        # Send response (handle long messages)
+        await send_long_message(message, response)
+
+    except Exception as e:
+        logger.error("Error in chat handler: %s", e, exc_info=True)
+        await message.answer(
+            "❌ Ошибка при обращении к модели. Попробуйте позже."
+        )
+

handlers commands.py

@@ -0,0 +1,55 @@
+import asyncio
+import logging
+from aiogram import Router, types
+from aiogram.filters import Command
+from database import db
+
+logger = logging.getLogger(__name__)
+router = Router()
+
+
+@router.message(Command("start"))
+async def cmd_start(message: types.Message) -> None:
+    await message.answer(
+        "👋 Привет! Я AI-ассистент на базе GLM-5.1.\n\n"
+        "Отправь любое сообщение — я отвечу.\n"
+        "Используй /help для списка команд."
+    )
+
+
+@router.message(Command("help"))
+async def cmd_help(message: types.Message) -> None:
+    await message.answer(
+        "📋 <b>Команды:</b>\n\n"
+        "/start — Начать работу\n"
+        "/help — Помощь\n"
+        "/clear — Очистить историю сообщений\n"
+        "/stats — Статистика\n"
+        "/ping — Проверка задержки"
+    )
+
+
+@router.message(Command("clear"))
+async def cmd_clear(message: types.Message) -> None:
+    count = await db.clear_history(message.from_user.id)
+    await message.answer(f"🗑 История очищена. Удалено сообщений: {count}.")
+
+
+@router.message(Command("stats"))
+async def cmd_stats(message: types.Message) -> None:
+    stats = await db.get_stats(message.from_user.id)
+    await message.answer(
+        f"📊 <b>Статистика:</b>\n\n"
+        f"Всего пользователей: {stats['total_users']}\n"
+        f"Ваших сообщений: {stats['user_messages']}\n"
+        f"Всего сообщений в боте: {stats['total_messages']}"
+    )
+
+
+@router.message(Command("ping"))
+async def cmd_ping(message: types.Message) -> None:
+    start = asyncio.get_event_loop().time()
+    msg = await message.answer("🏓 Pong!")
+    end = asyncio.get_event_loop().time()
+    latency = (end - start) * 1000
+    await msg.edit_text(f"🏓 Pong! Задержка: {latency:.1f} мс")

middlewares __init__.py

@@ -0,0 +1 @@
+from .owner import OwnerMiddleware

middlewares owner.py

@@ -0,0 +1,26 @@
+import logging
+from typing import Any, Awaitable, Callable, Dict
+from aiogram import BaseMiddleware
+from aiogram.types import Message, TelegramObject
+from config import config
+
+logger = logging.getLogger(__name__)
+
+
+class OwnerMiddleware(BaseMiddleware):
+    async def __call__(
+        self,
+        handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]],
+        event: TelegramObject,
+        data: Dict[str, Any],
+    ) -> Any:
+        if not isinstance(event, Message):
+            return await handler(event, data)
+
+        user_id = event.from_user.id
+        if user_id != config.OWNER_ID:
+            logger.warning("Unauthorized access from user_id=%s", user_id)
+            await event.answer("⛔ Доступ запрещён. Этот бот только для владельца.")
+            return None
+
+        return await handler(event, data)

service __init__.py

@@ -0,0 +1,2 @@
+from .glm import glm_service
+

services glm.py

@@ -0,0 +1,76 @@
+import openai
+import logging
+from typing import List, Dict, Any
+from config import config
+
+logger = logging.getLogger(__name__)
+
+
+class GLMService:
+    def __init__(self) -> None:
+        self.client = openai.AsyncOpenAI(
+            base_url=config.NVIDIA_BASE_URL,
+            api_key=config.NVIDIA_API_KEY,
+            timeout=60.0,
+            max_retries=2,
+        )
+        self.model = config.MODEL_NAME
+    async def chat(self, messages: List[Dict[str, str]]) -> str:
+        try:
+            response = await self.client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+                temperature=config.GLM_TEMPERATURE,
+                top_p=config.GLM_TOP_P,
+                frequency_penalty=config.GLM_FREQUENCY_PENALTY,
+                presence_penalty=config.GLM_PRESENCE_PENALTY,
+                max_tokens=config.GLM_MAX_TOKENS,
+            )
+            content = response.choices[0].message.content
+            if not content:
+                logger.warning("Empty response from GLM")
+                return "(пустой ответ от модели)"
+            logger.info("GLM response received, length: %d", len(content))
+            return content
+        except openai.APIError as e:
+            logger.error("GLM API error: %s", e)
+            raise
+        except Exception as e:
+            logger.error("Unexpected GLM error: %s", e)
+            raise
+
+    async def summarize(self, dialog_text: str) -> str:
+        """Суммаризировать диалог через GLM."""
+        try:
+            messages = [
+                {
+                    "role": "system",
+                    "content": (
+                        "Суммаризируй следующий диалог между пользователем и ассистентом. "
+                        "Сохрани ключевые факты, предпочтения пользователя, важные детали и контекст. "
+                        "Будь краток, максимум 4096 токенов. Используй русский язык."
+                    )
+                },
+                {"role": "user", "content": dialog_text}
+            ]
+            response = await self.client.chat.completions.create(
+                model=self.model,
+                messages=messages,
+                temperature=0.1,
+                max_tokens=config.SUMMARY_MAX_TOKENS,
+            )
+            content = response.choices[0].message.content
+            if not content:
+                logger.warning("Empty summary from GLM")
+                return ""
+            logger.info("Summary generated, length: %d", len(content))
+            return content
+        except Exception as e:
+            logger.error("Summary generation failed: %s", e)
+            return ""
+
+   
+
+
+glm_service = GLMService()
+

utils helpers.py

@@ -0,0 +1,17 @@
+import logging
+from aiogram import types
+from config import config
+
+logger = logging.getLogger(__name__)
+MAX_LENGTH = config.MAX_MESSAGE_LENGTH
+
+
+async def send_long_message(message: types.Message, text: str) -> None:
+    """Split long messages into chunks of MAX_LENGTH characters."""
+    if len(text) <= MAX_LENGTH:
+        await message.answer(text)
+        return
+
+    for i in range(0, len(text), MAX_LENGTH):
+        chunk = text[i:i + MAX_LENGTH]
+        await message.answer(chunk)