telegram-cli-bot/bot.py

#!/usr/bin/env python3
"""
Telegram CLI Bot - бот для выполнения CLI команд с многоуровневым меню.
Версия: 0.5.3 (модульная структура)
"""

import os
import sys
import asyncio
import subprocess
import logging
import pty
import select
import fcntl
from pathlib import Path
from typing import Optional, Callable, Dict, Any, List, Tuple
from datetime import datetime, timedelta

import pexpect
import asyncssh
from qwen_integration import qwen_manager, QwenSessionState

# Подавляем логи sentence-transformers и huggingface
logging.getLogger("sentence_transformers").setLevel(logging.WARNING)
logging.getLogger("huggingface_hub").setLevel(logging.WARNING)
logging.getLogger("httpx").setLevel(logging.WARNING)

from vector_memory import (
    hybrid_memory_manager,
    save_message,
    get_context,
    get_profile,
    get_memory_stats
)

# Импорты компактификации
from bot.compaction import init_compactor, get_compactor, DialogueCompactor

from dotenv import load_dotenv
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup, BotCommand
from telegram.ext import (
    Application,
    CommandHandler,
    CallbackQueryHandler,
    MessageHandler,
    ContextTypes,
    filters,
)

# Загрузка переменных окружения из .env
load_dotenv()

# --- Конфигурация ---
BASE_DIR = Path(__file__).parent

logging.basicConfig(
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
    level=logging.INFO,
    handlers=[
        logging.FileHandler(BASE_DIR / "bot.log"),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)


# ============================================================================
# ИМПОРТЫ ИЗ bot/ - модульная структура
# ============================================================================
from bot.config import config, state_manager, menu_builder, command_registry, server_manager
from bot.models.server import Server
from bot.models.session import SSHSession, SSHSessionManager, LocalSession, LocalSessionManager, INPUT_PATTERNS
from bot.utils.cleaners import clean_ansi_codes, normalize_output
from bot.utils.formatters import escape_markdown, split_message, send_long_message, format_long_output, MAX_MESSAGE_LENGTH
from bot.utils.ssh_readers import detect_input_type, read_ssh_output, read_pty_output
from bot.utils.decorators import check_access
from bot.keyboards.menus import MenuItem, init_menus

# Импорты хендлеров из модулей
from bot.handlers.commands import start_command, menu_command, help_command, settings_command
from bot.handlers.callbacks import menu_callback
from bot.services.command_executor import execute_cli_command

# Импорты инструментов и AI агента
from bot.ai_agent import ai_agent
from bot.tools import tools_registry

# Глобальные менеджеры сессий
ssh_session_manager = SSHSessionManager()
local_session_manager = LocalSessionManager()
compactor: Optional[DialogueCompactor] = None


async def handle_text_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обработка текстовых сообщений как CLI команд."""
    user_id = update.effective_user.id
    text = update.message.text.strip()
    state = state_manager.get(user_id)
    
    logger.info(f"handle_text_message: user_id={user_id}, ai_chat_mode={state.ai_chat_mode}, text={text[:50]}")

    # Проверка: не в режиме ввода данных сервера ли мы
    if state.waiting_for_input:
        await handle_server_input(update, text)
        return

    # Проверка: не активная ли SSH-сессия ожидает ввода
    ssh_session = ssh_session_manager.get_session(user_id)
    if ssh_session and ssh_session.waiting_for_input:
        await handle_ssh_session_input(update, text, ssh_session)
        return

    # Проверка: не активная ли локальная сессия ожидает ввода
    local_session = local_session_manager.get_session(user_id)
    if local_session and local_session.waiting_for_input:
        await handle_local_session_input(update, text, local_session)
        return

    # ПРОВЕРКА: режим чата с ИИ агентом
    if state.ai_chat_mode:
        logger.info(f"Пользователь {user_id} отправил задачу ИИ: {text}")
        await handle_ai_task(update, text)
        return

    # Любое текстовое сообщение = CLI команда
    logger.info(f"Пользователь {user_id} отправил команду: {text}")

    await execute_cli_command_from_message(update, text)


async def handle_ai_task(update: Update, text: str):
    """Обработка задачи для ИИ агента с использованием системы памяти и инструментов."""
    user_id = update.effective_user.id
    state = state_manager.get(user_id)

    # === ПРОВЕРКА: Нужна ли компактификация? ===
    global compactor
    if compactor is None:
        compactor = init_compactor(qwen_manager, hybrid_memory_manager.vector)
        logger.info("Компактор инициализирован")

    # Проверяем порог заполненности контекста
    if compactor.check_compaction_needed():
        logger.info("Запуск компактификации истории диалога...")
        status_msg = await update.message.reply_text("🔄 **Запуск компактификации истории...**\n\n_Это может занять несколько секунд._", parse_mode="Markdown")

        result = await compactor.compact()

        await status_msg.delete()

        if result.success:
            await update.message.reply_text(
                f"✅ **Компактификация завершена!**\n\n"
                f"📊 Сжато сообщений: {result.messages_compressed}\n"
                f"📝 Длина summary: {result.summary_length} символов\n"
                f"💾 Экономия токенов: ~{result.tokens_saved}",
                parse_mode="Markdown"
            )
        else:
            logger.error(f"Компактификация не удалась: {result.error}")
            await update.message.reply_text(f"⚠️ **Ошибка компактификации:** {result.error}", parse_mode="Markdown")

    # Сохраняем сообщение пользователя в памяти
    save_message(user_id, "user", text)

    # Добавляем сообщение пользователя в историю сессии
    state.ai_chat_history.append(f"User: {text}")

    # Ограничиваем историю последними 20 сообщениями
    if len(state.ai_chat_history) > 20:
        state.ai_chat_history = state.ai_chat_history[-20:]

    # Отправляем статус
    status_msg = await update.message.reply_text("⏳ 🤖 Думаю...")

    # === ПРОВЕРКА: Решение AI агента об использовании инструментов ===
    agent_decision = await ai_agent.decide(text, context={'user_id': user_id})
    
    if agent_decision.should_use_tool:
        logger.info(f"AI агент решил использовать инструмент: {agent_decision.tool_name} (confidence={agent_decision.confidence})")
        
        # Выполняем инструмент
        tool_result = await ai_agent.execute_tool(
            agent_decision.tool_name,
            **agent_decision.tool_args
        )
        
        if tool_result.success:
            # Формируем ответ с результатами инструмента
            full_output = format_tool_result(agent_decision.tool_name, tool_result)
            
            # Добавляем в историю
            state.ai_chat_history.append(f"Assistant: {full_output[:500]}")
            save_message(user_id, "assistant", full_output)
            
            # Отправляем ответ
            if len(full_output) > 3500:
                full_output = full_output[:3500] + "\n... (вывод обрезан)"
            
            await send_long_message(update, full_output, parse_mode="Markdown")
            await status_msg.delete()
            return
        else:
            logger.warning(f"Инструмент {agent_decision.tool_name} вернул ошибку: {tool_result.error}")
            # Продолжаем с обычным ИИ-ответом если инструмент не сработал

    # === ОБЫЧНЫЙ ИИ-ОТВЕТ через Qwen ===
    output_buffer = []

    def on_output(text: str):
        output_buffer.append(text)

    def on_oauth_url(url: str):
        pass  # OAuth обрабатывается автоматически

    # Формируем контекст с историей + памятью + summary
    # Получаем summary и последние сообщения из ChromaDB
    summary = None
    try:
        summary, recent_messages = compactor.get_context_with_summary(limit=20)
        # Формируем историю из последних сообщений
        history_context = "\n".join([f"{msg['role']}: {msg['content']}" for msg in recent_messages])
    except Exception as e:
        logger.error(f"Ошибка загрузки summary: {e}")
        # Fallback на старую логику
        history_context = "\n".join(state.ai_chat_history)

    # Получаем контекст из системы памяти (профиль + релевантные факты)
    memory_context = get_context(user_id, query=text)

    # Считаем токены в контексте (примерно: 1 слово ≈ 1.3 токена)
    context_words = len((memory_context + "\n" + history_context).split())
    context_tokens = int(context_words * 1.3)

    # Максимальный контекст модели (Qwen поддерживает до 256K токенов)
    # Для безопасности берём 200K
    MAX_CONTEXT_TOKENS = 200_000
    context_percent = round((context_tokens / MAX_CONTEXT_TOKENS) * 100, 1)

    # Собираем полный промпт с системным промптом
    system_prompt = qwen_manager.load_system_prompt()

    # Формируем полный промпт с summary (если есть)
    if summary:
        full_task = (
            f"{system_prompt}\n\n"
            f"=== SUMMARY ДИАЛОГА (контекст) ===\n"
            f"{summary}\n\n"
            f"=== КОНТЕКСТ ПАМЯТИ ===\n"
            f"{memory_context}\n\n"
            f"=== ИСТОРИЯ ДИАЛОГА (последние 20 сообщений) ===\n"
            f"{history_context}\n\n"
            f"=== ЗАПРОС ПОЛЬЗОВАТЕЛЯ ===\n"
            f"{text}"
        )
    else:
        full_task = (
            f"{system_prompt}\n\n"
            f"=== КОНТЕКСТ ПАМЯТИ ===\n"
            f"{memory_context}\n\n"
            f"=== ИСТОРИЯ ДИАЛОГА ===\n"
            f"{history_context}\n\n"
            f"=== ЗАПРОС ПОЛЬЗОВАТЕЛЯ ===\n"
            f"{text}"
        )

    # Выполняем задачу (системный промпт уже добавлен в full_task)
    result = await qwen_manager.run_task(user_id, full_task, on_output, on_oauth_url, use_system_prompt=False)

    # Показываем результат
    full_output = "".join(output_buffer).strip()

    if not full_output:
        full_output = result

    # Добавляем ответ ИИ в историю и память
    if full_output:
        state.ai_chat_history.append(f"Assistant: {full_output[:500]}")
        save_message(user_id, "assistant", full_output)

    # Обрезаем если слишком длинный (с запасом на контекст)
    if len(full_output) > 3500:
        full_output = full_output[:3500] + "\n... (вывод обрезан)"

    # Автоматическое извлечение фактов каждые 5 сообщений
    state.messages_since_fact_extract += 1
    if state.messages_since_fact_extract >= 5:
        logger.info(f"Запуск извлечения фактов через ИИ для пользователя {user_id}")
        dialog_context = "\n".join(state.ai_chat_history[-10:])  # Последние 10 сообщений
        asyncio.create_task(hybrid_memory_manager.extract_facts_with_ai(user_id, dialog_context))
        state.messages_since_fact_extract = 0

    # Формируем сообщение с информацией о контексте (как в qwen-code)
    context_info = f"📊 Контекст: {context_percent}%"
    response_text = f"{full_output}\n\n*{context_info}*"

    # Отправляем ответ с разбивкой на части если нужно
    await send_long_message(update, response_text, parse_mode="Markdown")


def format_tool_result(tool_name: str, result: 'ToolResult') -> str:
    """Форматировать результат выполнения инструмента."""
    from bot.tools import ToolResult

    if tool_name == 'ddgs_search':
        if not result.data:
            return "🔍 Ничего не найдено по вашему запросу."

        output = "🔍 **Результаты поиска:**\n\n"
        for i, item in enumerate(result.data[:5], 1):
            title = item.get('title', 'Без названия')
            href = item.get('href', '')
            body = item.get('body', '')[:200]
            output += f"{i}. **{title}**\n"
            if href:
                output += f"   {href}\n"
            if body:
                output += f"   {body}\n\n"

        return output

    elif tool_name == 'rss_reader':
        action = result.metadata.get('action', 'list')

        if action == 'list' and result.data:
            output = "📰 **Последние новости:**\n\n"
            for i, item in enumerate(result.data[:10], 1):
                title = item.get('title', 'Без названия')
                pub_date = item.get('pub_date', '')
                link = item.get('link', '')[:50]
                output += f"{i}. {title}\n"
                if pub_date:
                    output += f"   📅 {pub_date}\n"
                if link:
                    output += f"   🔗 {link}\n\n"
            return output

        elif action == 'fetch':
            total = result.data.get('total_new_items', 0) if result.data else 0
            return f"✅ Получено {total} новых элементов из лент."

        elif action == 'list_feeds' and result.data:
            output = "📑 **Ваши RSS ленты:**\n\n"
            for feed in result.data:
                output += f"• {feed.get('title', feed.get('url', 'Unknown'))}\n"
            return output

        return f"RSS: {result.data}"

    elif tool_name == 'ssh_executor':
        if not result.success:
            return f"❌ **Ошибка SSH:**\n```\n{result.error}\n```"

        data = result.data
        server = result.metadata.get('server', 'unknown')
        command = result.metadata.get('command', '')

        output = f"🖥️ **SSH: {server}**\n"
        output += f"**Команда:** `{command}`\n\n"

        if data.get('stdout'):
            output += f"**Вывод:**\n```\n{data['stdout']}\n```\n\n"

        if data.get('stderr'):
            output += f"**Ошибки:**\n```\n{data['stderr']}\n```\n\n"

        if data.get('returncode') == 0:
            output += "✅ **Успешно**"
        else:
            output += f"❌ **Код возврата:** {data.get('returncode', 'N/A')}"

        return output

    elif tool_name == 'cron_manager':
        action = result.metadata.get('action', 'list')

        if action == 'list' and result.data:
            output = "⏰ **Ваши задачи:**\n\n"
            for job in result.data:
                status = "✅" if job.get('enabled') else "❌"
                output += f"{status} **{job.get('name', 'Без названия')}**\n"
                output += f"   Команда: `{job.get('command', '')}`\n"
                output += f"   Расписание: {job.get('schedule', '')}\n"
                if job.get('next_run'):
                    output += f"   Следующий запуск: {job.get('next_run')}\n"
                output += "\n"
            return output

        elif action == 'add' and result.success:
            data = result.data
            return f"✅ **Задача добавлена:**\n• ID: {data.get('id')}\n• Название: {data.get('name')}\n• Расписание: {data.get('schedule')}\n• Следующий запуск: {data.get('next_run', 'N/A')}"

        elif action == 'remove' and result.success:
            return f"✅ **Задача удалена:** ID {result.data.get('id')}"

        elif action == 'run' and result.success:
            return f"✅ **Задача выполнена:** {result.data.get('message', '')}"

        return f"Cron: {result.data}"

    return f"Инструмент {tool_name}: {result.data}"


async def handle_ssh_session_input(update: Update, text: str, session: SSHSession):
    """Обработка ввода пользователя в активную SSH-сессию."""
    user_id = update.effective_user.id
    input_type = session.input_type
    
    logger.info(f"Пользователь {user_id} ввёл '{text}' в SSH-сессию (тип: {input_type})")
    
    try:
        # Отправляем ввод в SSH-процесс
        if input_type == "password":
            # Пароль отправляем с newline
            session.process.stdin.write(text + "\n")
        elif input_type == "confirm":
            # Подтверждение - y или n
            answer = "y" if text.lower() in ("y", "yes", "да", "д") else "n"
            session.process.stdin.write(answer + "\n")
        else:
            # Обычный ввод
            session.process.stdin.write(text + "\n")
        
        await session.process.stdin.drain()
        session.last_activity = datetime.now()
        
        # Читаем ответ
        output, is_done = await read_ssh_output(session.process, timeout=3.0)
        session.output_buffer += output
        
        # Проверяем тип ввода
        new_input_type = detect_input_type(output)
        
        if new_input_type == "password":
            session.waiting_for_input = True
            session.input_type = "password"
            await update.message.reply_text(
                f"⏳ *Требуется ввод*\n\n"
                f"🔐 *Запрошен пароль*\n\n"
                f"```\n{output.strip()[-200:] if output else 'Ожидание...'}\n```\n\n"
                f"Отправьте пароль в чат:",
                parse_mode="Markdown"
            )
            return
        elif new_input_type == "confirm":
            session.waiting_for_input = True
            session.input_type = "confirm"
            await update.message.reply_text(
                f"⏳ *Требуется ввод*\n\n"
                f"❓ *Требуется подтверждение*\n\n"
                f"```\n{output.strip()[-200:] if output else 'Ожидание...'}\n```\n\n"
                f"Отправьте `y` (да) или `n` (нет):",
                parse_mode="Markdown"
            )
            return
        elif is_done or new_input_type == "prompt":
            # Команда завершена
            await update.message.reply_text(
                f"✅ *Результат:*\n\n"
                f"```\n{session.command}\n```\n\n"
                f"```\n{session.output_buffer.strip()[-4000:]}\n```",
                parse_mode="Markdown"
            )
            ssh_session_manager.close_session(user_id)
            return
        else:
            # Команда ещё выполняется
            await update.message.reply_text(
                f"⏳ *Выполнение...*\n\n"
                f"```\n{output.strip()[-500:] if output else 'Выполняется...'}\n```",
                parse_mode="Markdown"
            )
            
            # Читаем остаток
            while not is_done:
                more_output, is_done = await read_ssh_output(session.process, timeout=5.0)
                output += more_output
                session.output_buffer += output
                session.last_activity = datetime.now()
                
                new_input_type = detect_input_type(output)
                if new_input_type in ("password", "confirm"):
                    session.waiting_for_input = True
                    session.input_type = new_input_type
                    await update.message.reply_text(
                        f"⏳ *Требуется ввод*\n\n"
                        f"{'🔐 *Запрошен пароль*' if new_input_type == 'password' else '❓ *Требуется подтверждение'}\n\n"
                        f"```\n{output.strip()[-200:]}\n```\n\n"
                        f"{'Отправьте пароль в чат:' if new_input_type == 'password' else 'Отправьте `y` (да) или `n` (нет):'}",
                        parse_mode="Markdown"
                    )
                    return
            
            # Завершено
            await update.message.reply_text(
                f"✅ *Результат:*\n\n"
                f"```\n{session.command}\n```\n\n"
                f"```\n{session.output_buffer.strip()[-4000:]}\n```",
                parse_mode="Markdown"
            )
            ssh_session_manager.close_session(user_id)
            
    except Exception as e:
        logger.error(f"Ошибка ввода в SSH-сессию: {e}")
        ssh_session_manager.close_session(user_id)
        await update.message.reply_text(
            f"❌ *Ошибка:*\n```\n{str(e)}\n```",
            parse_mode="Markdown"
        )


async def handle_local_session_input(update: Update, text: str, session: LocalSession):
    """Обработка ввода пользователя в локальную сессию."""
    user_id = update.effective_user.id
    input_type = session.input_type
    
    logger.info(f"Пользователь {user_id} ввёл '{text}' в локальную сессию (тип: {input_type})")
    
    try:
        child = session.context.get('child')
        if not child:
            raise Exception("Сессия не содержит child объект")
        
        # Отправляем ввод
        if input_type == "password":
            child.sendline(text)
        elif input_type == "confirm":
            answer = "y" if text.lower() in ("y", "yes", "да", "д") else "n"
            child.sendline(answer)
        else:
            child.sendline(text)
        
        session.last_activity = datetime.now()
        
        # Читаем ответ
        logger.info("Чтение ответа...")
        output = ""
        
        try:
            while True:
                line = child.read_nonblocking(size=4096, timeout=5.0)
                if not line:
                    break
                output += line
                logger.debug(f"Прочитано: {len(line)} символов")
                
                # Проверяем запрос ввода
                if detect_input_type(output):
                    break
                    
        except pexpect.TIMEOUT:
            pass
        except pexpect.EOF:
            pass
        
        logger.info(f"После ввода прочитано: {len(output)} символов")
        session.output_buffer += output
        
        # Проверяем тип ввода
        new_input_type = detect_input_type(output)

        if new_input_type == "password":
            session.waiting_for_input = True
            session.input_type = "password"
            await update.message.reply_text(
                f"⏳ *Требуется ввод*\n\n"
                f"🔐 *Запрошен пароль*\n\n"
                f"```\n{output.strip()[-200:] if output else 'Ожидание...'}\n```\n\n"
                f"Отправьте пароль в чат:",
                parse_mode="Markdown"
            )
            return
        elif new_input_type == "confirm":
            session.waiting_for_input = True
            session.input_type = "confirm"
            await update.message.reply_text(
                f"⏳ *Требуется ввод*\n\n"
                f"❓ *Требуется подтверждение*\n\n"
                f"```\n{output.strip()[-200:] if output else 'Ожидание...'}\n```\n\n"
                f"Отправьте `y` (да) или `n` (нет):",
                parse_mode="Markdown"
            )
            return
        else:
            # Команда завершена
            # Очищаем ANSI-коды и нормализуем вывод
            cleaned_output = clean_ansi_codes(session.output_buffer)
            cleaned_output = normalize_output(cleaned_output)

            # Форматируем длинный вывод: первые 5 и последние 10 строк
            formatted_output = format_long_output(cleaned_output.strip(), max_lines=15, head_lines=5, tail_lines=10)
            if len(formatted_output) > 4000:
                formatted_output = formatted_output[:4000] + "\n... (вывод обрезан)"

            await update.message.reply_text(
                f"✅ *Результат:*\n\n"
                f"```\n{session.command}\n```\n\n"
                f"```\n{formatted_output}\n```",
                parse_mode="Markdown"
            )
            local_session_manager.close_session(user_id)
            
    except Exception as e:
        logger.error(f"Ошибка ввода в локальную сессию: {e}")
        local_session_manager.close_session(user_id)
        await update.message.reply_text(
            f"❌ *Ошибка:*\n```\n{str(e)}\n```",
            parse_mode="Markdown"
        )


async def handle_server_input(update: Update, text: str):
    """Обработка ввода данных для CRUD операций с серверами."""
    user_id = update.effective_user.id
    state = state_manager.get(user_id)
    input_type = state.input_type

    if input_type == "add_server_name":
        # Проверка имени
        if not text.replace("-", "").replace("_", "").isalnum():
            await update.message.reply_text(
                "❌ Неверный формат имени.\n\n"
                "Используйте только латиницу, дефисы и подчёркивания.\n"
                "Пример: `web-prod`, `db_backup`",
                parse_mode="Markdown",
                reply_markup=InlineKeyboardMarkup([[
                    InlineKeyboardButton("❌ Отмена", callback_data="server_menu")
                ]])
            )
            return
        
        state.context["new_server"]["name"] = text
        state.input_type = "add_server_host"
        await update.message.reply_text(
            f"✅ Имя: `{text}`\n\n"
            "Введите *host* (IP или домен):\n"
            "Пример: `192.168.1.10`, `example.com`",
            parse_mode="Markdown",
            reply_markup=InlineKeyboardMarkup([[
                InlineKeyboardButton("❌ Отмена", callback_data="server_menu")
            ]])
        )

    elif input_type == "add_server_host":
        state.context["new_server"]["host"] = text
        state.input_type = "add_server_port"
        await update.message.reply_text(
            f"✅ Host: `{text}`\n\n"
            "Введите *SSH порт* (обычно 22):",
            parse_mode="Markdown",
            reply_markup=InlineKeyboardMarkup([[
                InlineKeyboardButton("❌ Отмена", callback_data="server_menu")
            ]])
        )

    elif input_type == "add_server_port":
        try:
            port = int(text)
            if port < 1 or port > 65535:
                raise ValueError()
            state.context["new_server"]["port"] = port
            state.input_type = "add_server_user"
            await update.message.reply_text(
                f"✅ Port: `{port}`\n\n"
                "Введите *SSH пользователя*:\n"
                "Пример: `root`, `admin`, `ubuntu`",
                parse_mode="Markdown",
                reply_markup=InlineKeyboardMarkup([[
                    InlineKeyboardButton("❌ Отмена", callback_data="server_menu")
                ]])
            )
        except ValueError:
            await update.message.reply_text(
                "❌ Неверный формат порта.\n\n"
                "Введите число от 1 до 65535:",
                parse_mode="Markdown",
                reply_markup=InlineKeyboardMarkup([[
                    InlineKeyboardButton("❌ Отмена", callback_data="server_menu")
                ]])
            )

    elif input_type == "add_server_user":
        state.context["new_server"]["user"] = text
        state.input_type = "add_server_password"
        await update.message.reply_text(
            f"✅ User: `{text}`\n\n"
            "Введите *SSH пароль* (или нажмите Пропустить для подключения только по ключу):\n"
            "⚠️ Пароль будет сохранён в .env файл в открытом виде!",
            parse_mode="Markdown",
            reply_markup=InlineKeyboardMarkup([
                [InlineKeyboardButton("⏭️ Пропустить", callback_data="srv_skip_password")],
                [InlineKeyboardButton("❌ Отмена", callback_data="server_menu")]
            ])
        )

    elif input_type == "add_server_password":
        state.context["new_server"]["password"] = text
        state.input_type = "add_server_tags"
        await update.message.reply_text(
            "✅ Пароль сохранён\n\n"
            "Введите *теги* через запятую (или нажмите Пропустить):\n"
            "Пример: `web,prod`, `db,backup`\n\n"
            "Теги помогают группировать серверы.",
            parse_mode="Markdown",
            reply_markup=InlineKeyboardMarkup([
                [InlineKeyboardButton("⏭️ Пропустить", callback_data="srv_skip_tags")],
                [InlineKeyboardButton("❌ Отмена", callback_data="server_menu")]
            ])
        )

    elif input_type == "add_server_tags":
        # Обработка ввода тегов (если пользователь ввёл текстом, а не нажал кнопку)
        tags = [t.strip() for t in text.split(",") if t.strip()]
        state.context["new_server"]["tags"] = tags

        # Завершение добавления
        new_server = state.context.get("new_server", {})
        if server_manager.add_server(
            name=new_server["name"],
            host=new_server["host"],
            port=new_server["port"],
            user=new_server["user"],
            tags=tags,
            password=new_server.get("password", "")
        ):
            await update.message.reply_text(
                "✅ *Сервер добавлен*\n\n"
                f"Имя: `{new_server['name']}`\n"
                f"Host: `{new_server['host']}`\n"
                f"Port: `{new_server['port']}`\n"
                f"User: `{new_server['user']}`\n"
                f"Tags: `{','.join(tags)}`\n"
                f"Password: {'установлен' if new_server.get('password') else 'не установлен'}\n\n"
                f"Сервер сохранён в `.env` и доступен для выбора.",
                parse_mode="Markdown",
                reply_markup=menu_builder.get_keyboard("server")
            )
        else:
            await update.message.reply_text(
                "❌ Ошибка: сервер с таким именем уже существует",
                reply_markup=menu_builder.get_keyboard("server")
            )

        state.waiting_for_input = False
        state.input_type = None
        state.context.clear()

    elif input_type == "edit_server_field":
        # Выбор поля для редактирования
        if text == "1":
            state.input_type = "edit_server_host"
            await update.message.reply_text(
                "Введите новый *host*:",
                parse_mode="Markdown"
            )
        elif text == "2":
            state.input_type = "edit_server_port"
            await update.message.reply_text(
                "Введите новый *port*:",
                parse_mode="Markdown"
            )
        elif text == "3":
            state.input_type = "edit_server_user"
            await update.message.reply_text(
                "Введите нового *user*:",
                parse_mode="Markdown"
            )
        elif text == "4":
            state.input_type = "edit_server_tags"
            await update.message.reply_text(
                "Введите новые *теги* через запятую:",
                parse_mode="Markdown"
            )
        elif text == "5":
            state.input_type = "edit_server_password"
            await update.message.reply_text(
                "Введите новый *password* (или оставьте пустым для подключения только по ключу):\n"
                "⚠️ Пароль будет сохранён в .env файл в открытом виде!",
                parse_mode="Markdown"
            )
        else:
            await update.message.reply_text(
                "❌ Введите номер поля (1-5):",
                reply_markup=InlineKeyboardMarkup([[
                    InlineKeyboardButton("❌ Отмена", callback_data="server_menu")
                ]])
            )
        return

    elif input_type == "edit_server_host":
        server_manager.update_server(state.editing_server, host=text)
        await finish_edit_server(update, state)

    elif input_type == "edit_server_port":
        try:
            port = int(text)
            server_manager.update_server(state.editing_server, port=port)
            await finish_edit_server(update, state)
        except ValueError:
            await update.message.reply_text("❌ Неверный формат порта")
            return

    elif input_type == "edit_server_user":
        server_manager.update_server(state.editing_server, user=text)
        await finish_edit_server(update, state)

    elif input_type == "edit_server_tags":
        tags = [t.strip() for t in text.split(",") if t.strip()]
        server_manager.update_server(state.editing_server, tags=tags)
        await finish_edit_server(update, state)

    elif input_type == "edit_server_password":
        server_manager.update_server(state.editing_server, password=text)
        await finish_edit_server(update, state)

    else:
        # Неизвестный тип ввода - выполняем команду
        await execute_cli_command_from_message(update, text)
        return

    # Сброс состояния после завершения
    if not state.waiting_for_input or input_type.startswith("add_server_tags"):
        state.waiting_for_input = False
        state.input_type = None
        state.context.clear()


async def finish_edit_server(update: Update, state):
    """Завершение редактирования сервера."""
    server_name = state.editing_server
    state.waiting_for_input = False
    state.input_type = None
    state.editing_server = None
    
    server = server_manager.get(server_name)
    if server:
        await update.message.reply_text(
            "✅ *Сервер обновлён*\n\n"
            f"{server.display_name}\n"
            f"📍 `{server.description}`",
            parse_mode="Markdown",
            reply_markup=menu_builder.get_keyboard("server")
        )
    else:
        await update.message.reply_text(
            "❌ Ошибка при обновлении сервера",
            reply_markup=menu_builder.get_keyboard("server")
        )


async def execute_cli_command_from_message(update: Update, command: str):
    """Выполнение CLI команды из сообщения."""
    user_id = update.effective_user.id
    state = state_manager.get(user_id)
    server_name = state.current_server
    server = server_manager.get(server_name)

    # Определяем рабочую директорию
    working_dir = state.working_directory or config.working_directory

    # Обработка команды cd - меняем директорию пользователя
    # Работает только с простыми командами cd, не с составными
    cmd_stripped = command.strip()
    if cmd_stripped.startswith("cd ") and "&&" not in cmd_stripped and ";" not in cmd_stripped and "|" not in cmd_stripped:
        parts = cmd_stripped.split(maxsplit=1)
        if len(parts) == 2:
            target_dir = parts[1]

            # Обработка ~ и относительных путей
            if target_dir.startswith("~"):
                target_dir = str(Path.home()) + target_dir[1:]
            elif not target_dir.startswith("/"):
                target_dir = str(Path(working_dir) / target_dir)

            # Проверка существования директории
            if Path(target_dir).is_dir():
                state.working_directory = target_dir
                await update.message.reply_text(
                    f"📁 *Директория изменена:*\n`{target_dir}`\n"
                    f"🖥️ Сервер: `{server_name}`",
                    parse_mode="Markdown"
                )
            else:
                await update.message.reply_text(
                    f"❌ *Директория не найдена:*\n`{target_dir}`",
                    parse_mode="Markdown"
                )
        return

    # Для составных команд с cd — выполняем через SSH или локально
    if "cd " in cmd_stripped and ("&&" in cmd_stripped or ";" in cmd_stripped):
        if server_name == "local" or server is None:
            await _execute_composite_command_local(update, cmd_stripped, working_dir)
        else:
            await _execute_composite_command_ssh(update, cmd_stripped, server, working_dir)
        return

    # Обычное выполнение
    if server_name == "local" or server is None:
        await _execute_local_command_message(update, cmd_stripped, working_dir)
    else:
        await _execute_ssh_command_message(update, cmd_stripped, server, working_dir)


async def _execute_composite_command_local(update: Update, command: str, working_dir: str):
    """Выполнение составной команды локально."""
    command_with_pwd = f"{command} && pwd"
    logger.info(f"Выполнение составной команды с cd: {command_with_pwd} в директории: {working_dir}")

    try:
        process = await asyncio.create_subprocess_shell(
            command_with_pwd,
            stdout=asyncio.subprocess.PIPE,
            stderr=asyncio.subprocess.PIPE,
            cwd=working_dir
        )

        stdout, stderr = await asyncio.wait_for(process.communicate(), timeout=30)
        output = stdout.decode("utf-8", errors="replace").strip()
        error = stderr.decode("utf-8", errors="replace")

        # Последняя строка - это pwd
        if output and process.returncode == 0:
            lines = output.split('\n')
            final_dir = lines[-1].strip()
            if Path(final_dir).is_dir():
                state_manager.get(update.effective_user.id).working_directory = final_dir
                output = '\n'.join(lines[:-1])

        await _show_result_message(update, command, output, error, process.returncode)

    except asyncio.TimeoutError:
        await update.message.reply_text("❌ *Таймаут*\n\nКоманда выполнялась дольше 30 секунд.", parse_mode="Markdown")
    except Exception as e:
        logger.error(f"Ошибка: {e}")
        await update.message.reply_text(f"❌ *Ошибка:*\n```\n{str(e)}\n```", parse_mode="Markdown")


async def _execute_composite_command_ssh(update: Update, command: str, server: Server, working_dir: str):
    """Выполнение составной команды через SSH с интерактивной сессией."""
    user_id = update.effective_user.id
    command_with_pwd = f"{command} && pwd"

    try:
        client_keys = [server_manager.ssh_key_path] if server_manager.ssh_key_path else None

        # Подготовка параметров подключения
        connect_kwargs = {
            "host": server.host,
            "port": server.port,
            "username": server.user,
            "client_host_keys": None,
            "known_hosts": None
        }

        if client_keys:
            connect_kwargs["client_keys"] = client_keys
        if server.password:
            connect_kwargs["password"] = server.password

        logger.info(f"SSH подключение к {server.host}:{server.port} как {server.user}")

        conn = await asyncssh.connect(**connect_kwargs)
        
        # Выполнение команды с cd в рабочую директорию
        full_command = f"cd {working_dir} && {command_with_pwd}" if working_dir else command_with_pwd
        
        # Создаем интерактивный процесс с PTY для поддержки ввода
        # TERM环境变量设置 для корректной кодировки
        process = await conn.create_process(
            full_command,
            term_type='xterm-256color',
            env={'LANG': 'C.UTF-8', 'LC_ALL': 'C.UTF-8'}
        )
        
        # Создаём сессию
        session = ssh_session_manager.create_session(
            user_id=user_id,
            server=server,
            working_dir=working_dir,
            conn=conn,
            process=process,
            command=command
        )
        
        # Читаем начальный вывод
        output, is_done = await read_ssh_output(process, timeout=3.0)
        session.output_buffer = output
        session.last_activity = datetime.now()

        # Читаем пока процесс не завершится
        while not is_done:
            more_output, is_done = await read_ssh_output(process, timeout=2.0)
            output += more_output
            session.output_buffer = output
            session.last_activity = datetime.now()

        # Проверяем тип ввода
        input_type = detect_input_type(output)

        if input_type == "password":
            session.waiting_for_input = True
            session.input_type = "password"
            await update.message.reply_text(
                f"⏳ *Требуется ввод*\n\n"
                f"Команда: `{command}`\n\n"
                f"🔐 *Запрошен пароль*\n\n"
                f"```\n{output.strip()[-200:]}\n```\n\n"
                f"Отправьте пароль в чат:",
                parse_mode="Markdown"
            )
            return
        elif input_type == "confirm":
            session.waiting_for_input = True
            session.input_type = "confirm"
            await update.message.reply_text(
                f"⏳ *Требуется ввод*\n\n"
                f"Команда: `{command}`\n\n"
                f"❓ *Требуется подтверждение*\n\n"
                f"```\n{output.strip()[-200:]}\n```\n\n"
                f"Отправьте `y` (да) или `n` (нет):",
                parse_mode="Markdown"
            )
            return
        else:
            # Обработка pwd для смены директории
            if output:
                lines = output.strip().split('\n')
                final_dir = lines[-1].strip()
                if final_dir.startswith('/'):
                    state_manager.get(user_id).working_directory = final_dir
                    output = '\n'.join(lines[:-1])

            ssh_session_manager.close_session(user_id)
            await _show_result_message(update, command, output, "", 0)
            return

    except asyncssh.Error as e:
        logger.error(f"SSH ошибка: {e}")
        ssh_session_manager.close_session(user_id)
        await update.message.reply_text(f"❌ *SSH ошибка:*\n```\n{str(e)}\n```", parse_mode="Markdown")
    except asyncio.TimeoutError:
        logger.error("Таймаут SSH подключения")
        ssh_session_manager.close_session(user_id)
        await update.message.reply_text("❌ *Таймаут*\n\nКоманда выполнялась дольше 30 секунд.", parse_mode="Markdown")
    except Exception as e:
        logger.error(f"Ошибка: {e}")
        ssh_session_manager.close_session(user_id)
        await update.message.reply_text(f"❌ *Ошибка:*\n```\n{str(e)}\n```", parse_mode="Markdown")


async def _execute_local_command_message(update: Update, command: str, working_dir: str):
    """Выполнение локальной команды из сообщения через pexpect."""
    user_id = update.effective_user.id
    
    try:
        logger.info(f"Запуск команды через pexpect: {command}")
        
        # Создаём интерактивный процесс
        child = pexpect.spawn(
            '/bin/bash',
            ['-c', command],
            cwd=working_dir,
            encoding='utf-8',
            codec_errors='replace',
            echo=False,
            timeout=30
        )
        
        # Создаём сессию (используем child вместо master_fd)
        session = local_session_manager.create_session(
            user_id=user_id,
            command=command,
            master_fd=child.child_fd,
            pid=child.pid
        )
        session.context = {'child': child}  # Сохраняем child объект
        
        # Читаем начальный вывод
        logger.info("Чтение вывода...")
        output = ""
        
        try:
            # Пробуем прочитать с таймаутом
            while True:
                line = child.read_nonblocking(size=4096, timeout=2.0)
                if not line:
                    break
                output += line
                logger.debug(f"Прочитано: {len(line)} символов")
                
                # Проверяем запрос ввода
                if detect_input_type(output):
                    break
                    
        except pexpect.TIMEOUT:
            pass
        except pexpect.EOF:
            pass
        
        logger.info(f"Прочитано: {len(output)} символов")
        session.output_buffer = output
        session.last_activity = datetime.now()
        
        # Проверяем тип ввода
        input_type = detect_input_type(output)
        logger.info(f"Тип ввода: {input_type}")
        
        if input_type == "password":
            session.waiting_for_input = True
            session.input_type = "password"
            await update.message.reply_text(
                f"⏳ *Требуется ввод*\n\n"
                f"Команда: `{command}`\n\n"
                f"🔐 *Запрошен пароль*\n\n"
                f"```\n{output.strip()[-200:]}\n```\n\n"
                f"Отправьте пароль в чат:",
                parse_mode="Markdown"
            )
            return
        elif input_type == "confirm":
            session.waiting_for_input = True
            session.input_type = "confirm"
            await update.message.reply_text(
                f"⏳ *Требуется ввод*\n\n"
                f"Команда: `{command}`\n\n"
                f"❓ *Требуется подтверждение*\n\n"
                f"```\n{output.strip()[-200:]}\n```\n\n"
                f"Отправьте `y` (да) или `n` (нет):",
                parse_mode="Markdown"
            )
            return
        else:
            # Команда завершена
            local_session_manager.close_session(user_id)
            await _show_result_message(update, command, output, "", 0)

    except Exception as e:
        logger.error(f"Ошибка выполнения команды: {e}")
        local_session_manager.close_session(user_id)
        await update.message.reply_text(f"❌ *Ошибка:*\n```\n{str(e)}\n```", parse_mode="Markdown")


async def _execute_ssh_command_message(update: Update, command: str, server: Server, working_dir: str):
    """Выполнение команды через SSH из сообщения с интерактивной сессией."""
    user_id = update.effective_user.id
    
    try:
        client_keys = [server_manager.ssh_key_path] if server_manager.ssh_key_path else None

        # Подготовка параметров подключения
        connect_kwargs = {
            "host": server.host,
            "port": server.port,
            "username": server.user,
            "client_host_keys": None,
            "known_hosts": None
        }

        if client_keys:
            connect_kwargs["client_keys"] = client_keys
        if server.password:
            connect_kwargs["password"] = server.password

        logger.info(f"SSH подключение к {server.host}:{server.port} как {server.user}")

        conn = await asyncssh.connect(**connect_kwargs)
        
        # Выполнение команды с cd в рабочую директорию
        full_command = f"cd {working_dir} && {command}" if working_dir else command
        
        # Создаем интерактивный процесс с PTY для поддержки ввода
        # TERM环境变量设置 для корректной кодировки
        process = await conn.create_process(
            full_command,
            term_type='xterm-256color',
            env={'LANG': 'C.UTF-8', 'LC_ALL': 'C.UTF-8'}
        )
        
        # Создаём сессию
        session = ssh_session_manager.create_session(
            user_id=user_id,
            server=server,
            working_dir=working_dir,
            conn=conn,
            process=process,
            command=command
        )
        
        # Читаем начальный вывод
        output, is_done = await read_ssh_output(process, timeout=3.0)
        session.output_buffer = output
        session.last_activity = datetime.now()

        # Читаем пока процесс не завершится
        while not is_done:
            more_output, is_done = await read_ssh_output(process, timeout=2.0)
            output += more_output
            session.output_buffer = output
            session.last_activity = datetime.now()

        # Проверяем тип ввода
        input_type = detect_input_type(output)

        if input_type == "password":
            session.waiting_for_input = True
            session.input_type = "password"
            await update.message.reply_text(
                f"⏳ *Требуется ввод*\n\n"
                f"Команда: `{command}`\n\n"
                f"🔐 *Запрошен пароль*\n\n"
                f"```\n{output.strip()[-200:]}\n```\n\n"
                f"Отправьте пароль в чат:",
                parse_mode="Markdown"
            )
            return
        elif input_type == "confirm":
            session.waiting_for_input = True
            session.input_type = "confirm"
            await update.message.reply_text(
                f"⏳ *Требуется ввод*\n\n"
                f"Команда: `{command}`\n\n"
                f"❓ *Требуется подтверждение*\n\n"
                f"```\n{output.strip()[-200:]}\n```\n\n"
                f"Отправьте `y` (да) или `n` (нет):",
                parse_mode="Markdown"
            )
            return
        else:
            # Команда завершена, показываем результат
            ssh_session_manager.close_session(user_id)
            await _show_result_message(update, command, output, "", 0)
            return

    except asyncssh.Error as e:
        logger.error(f"SSH ошибка: {e}")
        ssh_session_manager.close_session(user_id)
        await update.message.reply_text(f"❌ *SSH ошибка:*\n```\n{str(e)}\n```", parse_mode="Markdown")
    except asyncio.TimeoutError:
        logger.error("Таймаут SSH подключения")
        ssh_session_manager.close_session(user_id)
        await update.message.reply_text("❌ *Таймаут*\n\nКоманда выполнялась дольше 30 секунд.", parse_mode="Markdown")
    except Exception as e:
        logger.error(f"Ошибка: {e}")
        ssh_session_manager.close_session(user_id)
        await update.message.reply_text(f"❌ *Ошибка:*\n```\n{str(e)}\n```", parse_mode="Markdown")


async def _show_result_message(update: Update, command: str, output: str, error: str, returncode: int):
    """Показ результата выполнения команды."""
    # Очистка ANSI-кодов и нормализация
    output = normalize_output(clean_ansi_codes(output)) if output else ""
    error = clean_ansi_codes(error) if error else ""

    result = f"✅ *Результат:*\n\n"

    if output:
        # Форматируем длинный вывод: первые 5 и последние 10 строк
        output = format_long_output(output, max_lines=15, head_lines=5, tail_lines=10)
        result += f"```\n{output}\n```\n"

    if error:
        result += f"*Ошибки:*\n```\n{error}\n```\n"

    result += f"\n*Код возврата:* `{returncode}`"

    # Экранируем backticks и отправляем с разбивкой
    result = escape_markdown(result)
    await send_long_message(update, result, parse_mode="Markdown")


async def post_init(application: Application):
    """Инициализация после запуска бота."""
    # Установка команд бота
    commands = [
        BotCommand("start", "Запустить бота"),
        BotCommand("menu", "Главное меню с кнопками"),
        BotCommand("help", "Справка"),
        BotCommand("settings", "Настройки"),
        BotCommand("stop", "Прервать SSH-сессию"),
        BotCommand("ai", "Задача для Qwen Code AI"),
        BotCommand("memory", "Статистика памяти ИИ"),
        BotCommand("facts", "Показать сохранённые факты"),
        BotCommand("forget", "Удалить факт по номеру"),
    ]
    await application.bot.set_my_commands(commands)

    logger.info("Бот инициализирован")


@check_access
async def stop_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обработка команды /stop - прерывание активной SSH-сессии."""
    user_id = update.effective_user.id
    
    session = ssh_session_manager.get_session(user_id)
    if session:
        ssh_session_manager.close_session(user_id)
        await update.message.reply_text(
            "❌ *SSH-сессия прервана*\n\n"
            f"Команда `{session.command}` была остановлена.",
            parse_mode="Markdown"
        )
    else:
        await update.message.reply_text(
            "ℹ️ *Нет активных SSH-сессий*\n\n"
            "У вас нет выполняющихся команд.",
            parse_mode="Markdown"
        )




# ============================================
# КОМАНДЫ ДЛЯ РАБОТЫ С QWEN CODE (ИИ)
# ============================================

@check_access
async def ai_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обработка команды /ai - выполнение задачи через Qwen Code."""
    user_id = update.effective_user.id
    task = " ".join(context.args).strip()
    
    if not task:
        await update.message.reply_text(
            "🤖 *Qwen Code AI*\n\n"
            "Использование:\n"
            "`/ai <задача>`\n\n"
            "Примеры:\n"
            "`/ai создай функцию Python для сортировки списка`\n"
            "`/ai объясни код в файле main.py`\n"
            "`/ai найди баги в этом коде`\n\n"
            "Команды:\n"
            "`/ai status` — статус сессии\n"
            "`/ai stop` — завершить сессию\n"
            "`/ai clear` — очистить историю диалога",
            parse_mode="Markdown"
        )
        return
    
    # Специальные команды
    if task == "status":
        session = qwen_manager.get_session(user_id)
        if session:
            await update.message.reply_text(
                f"🤖 *Статус сессии Qwen Code*\n\n"
                f"Состояние: `{session.state.value}`\n"
                f"Последняя активность: {session.last_activity.strftime('%H:%M:%S')}\n"
                f"Задача: `{session.pending_task or 'Нет'}`",
                parse_mode="Markdown"
            )
        else:
            await update.message.reply_text("ℹ️ Активных сессий нет")
        return
    
    if task == "stop":
        qwen_manager.close_session(user_id)
        await update.message.reply_text("✅ Сессия Qwen Code завершена")
        return
    
    if task == "clear":
        state = state_manager.get(user_id)
        state.ai_chat_history.clear()
        await update.message.reply_text("✅ История диалога с ИИ очищена")
        return
    
    # Отправляем задачу в ИИ
    status_msg = await update.message.reply_text("⏳ 🤖 Думаю...", parse_mode="Markdown")
    
    output_buffer = []
    
    def on_output(text: str):
        output_buffer.append(text)
    
    def on_oauth_url(url: str):
        pass  # OAuth обрабатывается автоматически при первом запуске
    
    # Выполняем задачу
    result = await qwen_manager.run_task(user_id, task, on_output, on_oauth_url)
    
    # Показываем результат
    full_output = "".join(output_buffer).strip()
    
    if not full_output:
        full_output = result
    
    if len(full_output) > 4000:
        full_output = full_output[:4000] + "\n... (вывод обрезан)"
    
    await status_msg.edit_text(
        f"🤖 *Результат:*\n\n"
        f"```\n{full_output}\n```",
        parse_mode="Markdown"
    )


@check_access
async def compact_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обработка команды /compact — ручная компактификация истории диалога."""
    user_id = update.effective_user.id

    logger.info(f"Пользователь {user_id} запросил ручную компактификацию")

    status_msg = await update.message.reply_text(
        "🔄 **Запуск компактификации истории...**\n\n"
        "_Сжатие старой истории в структурированный summary._\n"
        "_Это может занять несколько секунд._",
        parse_mode="Markdown"
    )

    result = await compactor.compact()

    await status_msg.delete()

    if result.success:
        if result.messages_compressed > 0:
            await update.message.reply_text(
                f"✅ **Компактификация завершена!**\n\n"
                f"📊 Сжато сообщений: `{result.messages_compressed}`\n"
                f"📝 Длина summary: `{result.summary_length}` символов\n"
                f"💾 Экономия токенов: ~`{result.tokens_saved}`\n\n"
                f"_Summary автоматически используется в контексте диалога._",
                parse_mode="Markdown"
            )
        else:
            await update.message.reply_text(
                "ℹ️ **Компактификация не требуется**\n\n"
                "_Недостаточно сообщений для сжатия или summary уже актуален._",
                parse_mode="Markdown"
            )
    else:
        logger.error(f"Компактификация не удалась: {result.error}")
        await update.message.reply_text(
            f"⚠️ **Ошибка компактификации:**\n`{result.error}`",
            parse_mode="Markdown"
        )


@check_access
async def memory_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обработка команды /memory — статистика памяти ИИ."""
    user_id = update.effective_user.id

    stats = get_memory_stats(user_id)

    if not stats:
        await update.message.reply_text("ℹ️ Память не инициализирована")
        return

    # Форматируем статистику
    total_messages = stats.get("total_messages", 0)
    total_facts = stats.get("total_facts", 0)
    total_sessions = stats.get("total_sessions", 0)
    vector_docs = stats.get("vector_documents", "N/A")
    vector_model = stats.get("vector_model", "N/A")
    hybrid_mode = stats.get("hybrid_mode", False)

    text = (
        "🧠 *Статистика памяти:*\n\n"
        f"📊 Сообщений: `{total_messages}`\n"
        f"📌 Фактов: `{total_facts}`\n"
        f"📁 Сессий: `{total_sessions}`\n"
    )

    if hybrid_mode:
        text += (
            f"\n🔮 *Векторная память:*\n"
            f"  Документы: `{vector_docs}`\n"
            f"  Модель: `{vector_model}`\n"
        )

    text += "\n_Память использует SQLite + ChromaDB с семантическим поиском._"

    await update.message.reply_text(text, parse_mode="Markdown")


@check_access
async def facts_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обработка команды /facts — показать сохранённые факты."""
    user_id = update.effective_user.id
    
    # Получаем факты из SQLite
    from memory_system import memory_manager
    facts = memory_manager.storage.get_facts(user_id)
    
    if not facts:
        await update.message.reply_text(
            "📋 *Ваши факты*\n\n"
            "Пока нет сохранённых фактов.\n"
            "Общайтесь с ИИ в чате — он автоматически запомнит важное!",
            parse_mode="Markdown"
        )
        return
    
    # Группируем по типам
    from memory_system import FactType
    grouped = {}
    for fact in facts:
        type_name = fact.fact_type.value
        if type_name not in grouped:
            grouped[type_name] = []
        grouped[type_name].append(fact)
    
    # Формируем сообщение
    type_names_ru = {
        "personal": "👤 Личное",
        "technical": "💻 Технологии",
        "project": "📁 Проекты",
        "preference": "⭐ Предпочтения",
        "other": "📌 Другое"
    }
    
    text = "📋 *Ваши сохранённые факты:*\n\n"
    
    for type_name, type_facts in grouped.items():
        type_title = type_names_ru.get(type_name, type_name)
        text += f"*{type_title}* ({len(type_facts)}):\n"
        
        for i, fact in enumerate(type_facts, 1):
            # Обрезаем длинные факты
            content = fact.content
            if len(content) > 100:
                content = content[:100] + "..."
            text += f"  {i}. {content}\n"
        
        text += "\n"
    
    text += f"_Всего: {len(facts)} фактов_\n"
    text += "_Для удаления факта используйте `/forget <номер>`_"
    
    await update.message.reply_text(text, parse_mode="Markdown")


@check_access
async def forget_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Обработка команды /forget — удалить факт."""
    user_id = update.effective_user.id
    
    if not context.args or not context.args[0].isdigit():
        await update.message.reply_text(
            "❌ *Использование:*\n"
            "`/forget <номер>`\n\n"
            "Сначала вызовите `/facts` чтобы увидеть список.",
            parse_mode="Markdown"
        )
        return
    
    # Получаем факты
    from memory_system import memory_manager
    facts = memory_manager.storage.get_facts(user_id)
    
    fact_index = int(context.args[0]) - 1
    
    if fact_index < 0 or fact_index >= len(facts):
        await update.message.reply_text(
            f"❌ Факт с номером {fact_index + 1} не найден.\n"
            f"Всего фактов: {len(facts)}",
            parse_mode="Markdown"
        )
        return
    
    # Удаляем факт
    fact_to_delete = facts[fact_index]
    memory_manager.storage.update_fact(fact_to_delete.id, is_active=False)
    
    await update.message.reply_text(
        f"✅ Факт удалён:\n_{fact_to_delete.content}_",
        parse_mode="Markdown"
    )


def main():
    """Точка входа."""
    # Чтение токена только из переменной окружения
    token = os.getenv("TELEGRAM_BOT_TOKEN")

    if not token:
        print("❌ Ошибка: не установлен TELEGRAM_BOT_TOKEN")
        print("\nСпособы установки токена:")
        print("  1. Создайте файл .env по примеру .env.example")
        print("  2. Или задайте переменную окружения:")
        print("     export TELEGRAM_BOT_TOKEN='your_token_here'")
        print("\nИли запустите ./run.sh для интерактивной настройки")
        sys.exit(1)

    # Проверка настроек прокси
    use_proxy = os.getenv("USE_PROXY", "false").lower() == "true"
    proxy_url = None
    
    if use_proxy:
        proxy_host = os.getenv("PROXY_HOST", "127.0.0.1")
        proxy_port = os.getenv("PROXY_PORT", "1080")
        proxy_username = os.getenv("PROXY_USERNAME", "")
        proxy_password = os.getenv("PROXY_PASSWORD", "")
        
        # Формируем URL прокси: socks5://user:pass@host:port
        if proxy_username and proxy_password:
            proxy_url = f"socks5://{proxy_username}:{proxy_password}@{proxy_host}:{proxy_port}"
        else:
            proxy_url = f"socks5://{proxy_host}:{proxy_port}"
        
        print(f"✅ Прокси включён: {proxy_url.split('@')[0]}@{proxy_host}:{proxy_port}")

    # Загрузка серверов из env
    server_manager.load_from_env()

    # Инициализация меню
    init_menus(menu_builder)
    
    # Создание приложения с таймаутами и прокси
    builder = (
        Application.builder()
        .token(token)
        .post_init(post_init)
        .read_timeout(30)
        .write_timeout(30)
        .connect_timeout(30)
        .pool_timeout(30)
    )
    
    # Добавляем прокси если включён
    if use_proxy and proxy_url:
        builder = builder.proxy_url(proxy_url)
        logger.info(f"Используется SOCKS5 прокси: {proxy_host}:{proxy_port}")
    
    application = builder.build()
    
    # Регистрация хендлеров
    application.add_handler(CommandHandler("start", start_command))
    application.add_handler(CommandHandler("help", help_command))
    application.add_handler(CommandHandler("settings", settings_command))
    application.add_handler(CommandHandler("menu", menu_command))
    application.add_handler(CommandHandler("stop", stop_command))
    application.add_handler(CommandHandler("memory", memory_command))
    application.add_handler(CommandHandler("compact", compact_command))
    application.add_handler(CommandHandler("facts", facts_command))
    application.add_handler(CommandHandler("forget", forget_command))
    application.add_handler(CallbackQueryHandler(menu_callback))
    application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_text_message))
    application.add_handler(CommandHandler("ai", ai_command))
    
    # Запуск
    logger.info("Запуск бота...")
    print(f"🤖 {config.name} запущен!")
    print(f"📝 Описание: {config.description}")
    print(f"🎨 Иконка: {config.icon}")
    print("\nОстановка: Ctrl+C")
    
    application.run_polling(allowed_updates=Update.ALL_TYPES)


if __name__ == "__main__":
    main()