qwen-alpha 1.0.0

package/src/bot/handlers/message.js

@@ -0,0 +1,132 @@
+const sessionService = require('../../services/db/sessions');
+const statsService = require('../../services/db/stats');
+const { qwenService } = require('../../services/qwenService');
+const { logger } = require('../../utils/logger');
+
+/**
+ * Обработчик текстовых сообщений
+ * @param {import('telegraf').Context} ctx
+ */
+async function messageHandler(ctx) {
+  const userId = ctx.state.userId;
+  const chatId = ctx.state.chatId;
+  const isPrivate = ctx.state.isPrivate;
+  const text = ctx.message?.text;
+  
+  if (!text) {
+    return;
+  }
+  
+  // Проверка на команду /qwen в группах
+  const isQwenCommand = text.startsWith('/qwen') || text.startsWith('/qwen@');
+  const isBotMention = text.includes('@QwenAlphaRobot') || text.includes(`@${ctx.botInfo?.username}`);
+  const isReplyToBot = ctx.message?.reply_to_message?.from?.is_bot;
+  
+  // В личных чатах обрабатываем все сообщения
+  // В группах только /qwen, упоминания бота, или reply на бота
+  if (!isPrivate && !isQwenCommand && !isBotMention && !isReplyToBot) {
+    return;
+  }
+  
+  // Очистка команды из текста
+  let prompt = text;
+  if (isQwenCommand) {
+    prompt = text.replace(/^\/qwen(@\w+)?\s*/, '').trim();
+  }
+  
+  // Если пусто после очистки команды
+  if (!prompt && isQwenCommand) {
+    await ctx.reply('❌ Пожалуйста, укажите запрос после /qwen');
+    return;
+  }
+  
+  // Загрузка индикатора
+  const loadingMsg = isPrivate
+    ? await ctx.reply('⏳ Думаю...')
+    : null;
+  
+  try {
+    const startTime = Date.now();
+    
+    // Получение контекста из сессии
+    let contextMessages = [];
+    let session = ctx.state.session;
+    
+    if (session) {
+      // Если это reply на сообщение в сессии
+      const replyToMessageId = ctx.message?.reply_to_message?.message_id;
+      
+      if (replyToMessageId && session.message_tree[replyToMessageId]) {
+        // Получаем цепочку сообщений
+        contextMessages = sessionService.getMessageChain(session, replyToMessageId);
+      }
+    }
+    
+    // Запрос к Qwen
+    const result = await qwenService.analyzeCode(prompt, contextMessages);
+    
+    const duration = Date.now() - startTime;
+    statsService.updateAvgResponseTime(duration);
+    
+    // Форматирование ответа
+    let responseText = result;
+    
+    // В группах добавляем упоминание если это первый ответ
+    if (!isPrivate && ctx.message?.reply_to_message) {
+      const originalUser = ctx.message.reply_to_message.from;
+      if (originalUser?.username) {
+        responseText = `@${originalUser.username} ${responseText}`;
+      }
+    }
+    
+    // Отправка ответа
+    if (loadingMsg) {
+      await ctx.editMessageText(responseText, { parse_mode: 'Markdown' });
+    } else {
+      // В группах отвечаем reply на исходное сообщение
+      await ctx.reply(responseText, {
+        parse_mode: 'Markdown',
+        reply_parameters: { message_id: ctx.message.message_id },
+      });
+    }
+    
+    // Добавление сообщений в сессию
+    if (session) {
+      // Добавляем сообщение пользователя
+      sessionService.addMessage({
+        sessionId: session.session_id,
+        chatId,
+        messageId: ctx.message.message_id,
+        userId,
+        text: prompt,
+        type: 'user_question',
+      });
+      
+      // Добавляем ответ бота (будет добавлен после отправки)
+      // sessionService.addMessage({...})
+    }
+    
+    // Обновление статистики
+    statsService.incrementRequest();
+    userService.incrementRequest(userId);
+    
+    logger.info({ userId, chatId, duration, isPrivate }, 'Message processed');
+    
+  } catch (error) {
+    logger.error({ userId, chatId, error }, 'Message processing failed');
+    
+    if (loadingMsg) {
+      await ctx.editMessageText('❌ Ошибка при обработке запроса. Попробуйте позже.');
+    } else {
+      await ctx.reply('❌ Ошибка при обработке запроса. Попробуйте позже.', {
+        reply_parameters: { message_id: ctx.message.message_id },
+      });
+    }
+    
+    statsService.incrementError();
+  }
+}
+
+const userService = require('../../services/db/users');
+
+module.exports = messageHandler;

package/src/bot/handlers/reset.js

@@ -0,0 +1,53 @@
+const sessionService = require('../../services/db/sessions');
+const statsService = require('../../services/db/stats');
+const { logger } = require('../../utils/logger');
+
+/**
+ * Обработчик команды /reset
+ * Сброс текущей сессии пользователя
+ * @param {import('telegraf').Context} ctx
+ */
+async function resetHandler(ctx) {
+  const userId = ctx.state.userId;
+  const chatId = ctx.state.chatId;
+  const isPrivate = ctx.state.isPrivate;
+  
+  if (isPrivate) {
+    // Личный чат — сброс сессии пользователя
+    const sessionKey = `user:${userId}`;
+    const session = sessionService.getByKey(sessionKey);
+    
+    if (session) {
+      sessionService.close(session.session_id, chatId);
+      logger.info({ userId, sessionId: session.session_id }, 'Session reset by user');
+    }
+    
+    // Создание новой сессии
+    const newSession = sessionService.create({
+      userId,
+      chatId,
+      rootMessageId: ctx.message.message_id,
+      chatType: 'private',
+    });
+    
+    statsService.incrementSessionCreated();
+    
+    await ctx.reply(
+      '🔄 **Сессия сброшена**\n\n' +
+      'Контекст предыдущего диалога очищен. Начнём с чистого листа!',
+      { parse_mode: 'Markdown' }
+    );
+  } else {
+    // Групповой чат — информация
+    await ctx.reply(
+      '⚠️ **Сброс сессии в группах**\n\n' +
+      'В групповых чатах команда /reset не работает.\n\n' +
+      'Чтобы начать новую тему, просто отправьте:\n' +
+      '  `/qwen <ваш запрос>`\n\n' +
+      'Каждая тема — отдельная сессия с собственным контекстом.',
+      { parse_mode: 'Markdown' }
+    );
+  }
+}
+
+module.exports = resetHandler;

package/src/bot/handlers/settings.js

@@ -0,0 +1,39 @@
+const userService = require('../../services/db/users');
+const { storeManager } = require('../../services/db');
+const { logger } = require('../../utils/logger');
+
+/**
+ * Обработчик команды /settings
+ * Показывает и позволяет изменить настройки
+ * @param {import('telegraf').Context} ctx
+ */
+async function settingsHandler(ctx) {
+  const userId = ctx.state.userId;
+  const user = userService.getById(userId);
+  const globalSettings = storeManager.get('settings').getData();
+  
+  const settingsText = `
+⚙️ **Ваши настройки**
+
+**Модель:** ${user?.settings?.model || 'qwen3-coder-plus'}
+**Язык:** ${user?.settings?.language === 'ru' ? '🇷🇺 Русский' : '🇬🇧 English'}
+**Уведомления:** ${user?.settings?.notifications ? '✅ Вкл' : '❌ Выкл'}
+**Лимит запросов/час:** ${user?.settings?.requests_per_hour || 60}
+
+---
+🌍 **Глобальные настройки бота:**
+**Таймаут сессии:** ${globalSettings.session_timeout_hours}ч
+**Макс. размер файла:** ${globalSettings.max_file_size_mb}MB
+**Режим в группах:** ${globalSettings.group_mode}
+
+---
+**Изменение настроек:**
+/settings model <название> — сменить модель
+/settings language <ru|en> — сменить язык
+/settings notifications <on|off> — уведомления
+  `.trim();
+  
+  await ctx.reply(settingsText, { parse_mode: 'Markdown' });
+}
+
+module.exports = settingsHandler;

package/src/bot/handlers/start.js

@@ -0,0 +1,65 @@
+const adminService = require('../../services/db/admins');
+const sessionService = require('../../services/db/sessions');
+const statsService = require('../../services/db/stats');
+const { logger } = require('../../utils/logger');
+
+/**
+ * Обработчик команды /start
+ * Приветствие и регистрация пользователя
+ * @param {import('telegraf').Context} ctx
+ */
+async function startHandler(ctx) {
+  const userId = ctx.from.id;
+  const chatId = ctx.chat.id;
+  const isPrivate = chatId > 0 || userId === chatId;
+  
+  // Регистрация супер-админа если первый
+  const isNewSuperAdmin = ctx.state.isSuperAdmin;
+  
+  if (isNewSuperAdmin) {
+    logger.info({ userId }, 'Super admin registered via /start');
+    
+    await ctx.reply(
+      '🎉 **Поздравляю! Вы — первый пользователь и супер-администратор Qwen Alpha!**\n\n' +
+      'Теперь вы можете:\n' +
+      '• Управлять другими администраторами через /admin\n' +
+      '• Настраивать бота через /settings\n' +
+      '• Просматривать статистику через /stats\n\n' +
+      '📚 Документация: https://github.com/JeBance/QwenAlpha\n\n' +
+      'Для начала работы отправьте мне код или напишите /help',
+      { parse_mode: 'Markdown' }
+    );
+    
+    return;
+  }
+  
+  // Обычное приветствие
+  const welcomeMessages = [
+    '👋 Привет! Я Qwen Alpha — AI ассистент для работы с кодом.',
+    '🔍 Я умею:\n' +
+    '  • Code Review и поиск багов\n' +
+    '  • Генерация кода по описанию\n' +
+    '  • Объяснение сложных участков\n' +
+    '  • Рефакторинг и оптимизация\n\n' +
+    '📤 Отправь мне код текстом или файлом, и я проанализирую его!\n\n' +
+    'ℹ️ /help — список команд\n' +
+    '📊 /stats — ваша статистика\n' +
+    '⚙️ /settings — настройки',
+  ];
+  
+  await ctx.reply(welcomeMessages.join('\n'));
+  
+  // Создание сессии для личного чата если нет активной
+  if (isPrivate && !ctx.state.session) {
+    const session = sessionService.create({
+      userId,
+      chatId,
+      rootMessageId: ctx.message.message_id,
+      chatType: 'private',
+    });
+    ctx.state.session = session;
+    statsService.incrementSessionCreated();
+  }
+}
+
+module.exports = startHandler;

package/src/bot/handlers/stats.js

@@ -0,0 +1,76 @@
+const userService = require('../../services/db/users');
+const statsService = require('../../services/db/stats');
+const sessionService = require('../../services/db/sessions');
+const { logger } = require('../../utils/logger');
+
+/**
+ * Обработчик команды /stats
+ * Показывает статистику пользователя или чата
+ * @param {import('telegraf').Context} ctx
+ */
+async function statsHandler(ctx) {
+  const userId = ctx.state.userId;
+  const chatId = ctx.state.chatId;
+  const isPrivate = ctx.state.isPrivate;
+  
+  if (isPrivate) {
+    // Личная статистика
+    const user = userService.getById(userId);
+    const globalStats = statsService.getGlobal();
+    const todayStats = statsService.getDaily();
+    
+    const statsText = `
+📊 **Ваша статистика**
+
+**Запросы:**
+• Сегодня: ${user?.stats?.total_requests || 0}
+• Всего: ${user?.stats?.total_requests || 0}
+
+**Файлы:**
+• Проанализировано: ${user?.stats?.total_files || 0}
+
+**Токены:**
+• Использовано: ~${user?.stats?.total_tokens?.toLocaleString() || 0}
+
+**Группы:**
+• Использовано чатов: ${user?.stats?.groups_used || 0}
+
+---
+🌍 **Глобальная статистика:**
+• Пользователей: ${globalStats.total_users}
+• Активных за 24ч: ${globalStats.active_24h}
+• Запросов сегодня: ${globalStats.requests_today}
+• Среднее время ответа: ${globalStats.avg_response_time_ms}мс
+    `.trim();
+    
+    await ctx.reply(statsText, { parse_mode: 'Markdown' });
+  } else {
+    // Статистика чата
+    const sessions = sessionService.getChatSessions(chatId);
+    const activeSessions = sessions.filter(s => s.status === 'active');
+    const totalMessages = sessions.reduce((sum, s) => sum + (s.message_count || 0), 0);
+    const participants = new Set(sessions.flatMap(s => s.participants || []));
+    
+    const chatStatsText = `
+📊 **Статистика чата**
+
+**Сессии:**
+• Активных: ${activeSessions.length}
+• Всего: ${sessions.length}
+
+**Активность:**
+• Сообщений в сессиях: ${totalMessages}
+• Участников: ${participants.size}
+
+**Сессии:**
+${activeSessions.slice(0, 5).map(s => {
+      const timeLeft = Math.max(0, Math.floor((new Date(s.expires_at) - new Date()) / 3600000));
+      return `• Тема от ${s.root_user_id} (осталось ${timeLeft}ч)`;
+    }).join('\n') || 'Нет активных сессий'}
+    `.trim();
+    
+    await ctx.reply(chatStatsText, { parse_mode: 'Markdown' });
+  }
+}
+
+module.exports = statsHandler;

package/src/bot/middleware/auth.js

@@ -0,0 +1,70 @@
+const userService = require('../../services/db/users');
+const adminService = require('../../services/db/admins');
+const { logger } = require('../../utils/logger');
+const config = require('../../config');
+
+/**
+ * Middleware для аутентификации и авторизации пользователей
+ * @param {import('telegraf').Context} ctx
+ * @param {Function} next
+ */
+async function authMiddleware(ctx, next) {
+  const userId = ctx.from?.id;
+  
+  if (!userId) {
+    return next();
+  }
+  
+  // Проверка whitelist (если настроен)
+  if (config.bot.allowedUsers.length > 0) {
+    if (!config.bot.allowedUsers.includes(userId)) {
+      logger.warn({ userId }, 'User not in whitelist');
+      await ctx.reply('⛔ Доступ запрещён. Вы не в списке разрешённых пользователей.');
+      return;
+    }
+  }
+  
+  // Получение или создание пользователя
+  let user = userService.getById(userId);
+  
+  if (!user) {
+    user = userService.upsert({
+      id: userId,
+      username: ctx.from.username,
+      first_name: ctx.from.first_name,
+      last_name: ctx.from.last_name,
+    });
+    logger.info({ userId, username: ctx.from.username }, 'New user registered');
+  } else {
+    // Обновление last_seen и имени
+    userService.upsert({
+      id: userId,
+      username: ctx.from.username,
+      first_name: ctx.from.first_name,
+      last_name: ctx.from.last_name,
+    });
+  }
+  
+  // Проверка бана
+  if (user.is_banned) {
+    logger.warn({ userId }, 'Banned user attempted access');
+    await ctx.reply('⛔ Ваш аккаунт заблокирован.');
+    return;
+  }
+  
+  // Регистрация супер-админа (первый пользователь)
+  const isNewSuperAdmin = adminService.registerSuperAdmin(userId);
+  if (isNewSuperAdmin) {
+    logger.info({ userId }, 'First user registered as super admin');
+    ctx.state.isSuperAdmin = true;
+  } else {
+    ctx.state.isSuperAdmin = adminService.isSuperAdmin(userId);
+  }
+  
+  ctx.state.isAdmin = adminService.isAdmin(userId);
+  ctx.state.user = user;
+  
+  return next();
+}
+
+module.exports = { authMiddleware };

package/src/bot/middleware/logging.js

@@ -0,0 +1,55 @@
+const { logger } = require('../../utils/logger');
+
+/**
+ * Middleware для логирования входящих запросов
+ * Добавляет correlation ID для трассировки
+ * @param {import('telegraf').Context} ctx
+ * @param {Function} next
+ */
+async function loggingMiddleware(ctx, next) {
+  const correlationId = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  ctx.state.correlationId = correlationId;
+  
+  const logContext = {
+    correlationId,
+    userId: ctx.from?.id,
+    chatId: ctx.chat?.id,
+    chatType: ctx.chat?.type,
+    updateType: ctx.updateType,
+  };
+  
+  // Добавляем дополнительную информацию для разных типов обновлений
+  if (ctx.message) {
+    logContext.messageId = ctx.message.message_id;
+    logContext.hasText = !!ctx.message.text;
+    logContext.hasDocument = !!ctx.message.document;
+    logContext.hasPhoto = !!ctx.message.photo;
+    logContext.replyToMessageId = ctx.message.reply_to_message?.message_id;
+  }
+  
+  logger.info(logContext, 'Incoming update');
+  
+  const startTime = Date.now();
+  
+  try {
+    await next();
+    const duration = Date.now() - startTime;
+    
+    logger.info({
+      correlationId,
+      duration,
+    }, 'Update processed');
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    
+    logger.error({
+      correlationId,
+      duration,
+      error: error.message,
+    }, 'Update failed');
+    
+    throw error;
+  }
+}
+
+module.exports = { loggingMiddleware };

package/src/bot/middleware/rateLimit.js

@@ -0,0 +1,74 @@
+const { logger } = require('../../utils/logger');
+
+/**
+ * Хранилище запросов пользователей в памяти
+ * Ключ: user_id, Значение: массив временных меток
+ */
+const userRequests = new Map();
+
+/**
+ * Middleware для rate limiting
+ * Ограничивает количество запросов от пользователя в единицу времени
+ * @param {import('telegraf').Context} ctx
+ * @param {Function} next
+ */
+async function rateLimitMiddleware(ctx, next) {
+  const userId = ctx.from?.id;
+  
+  if (!userId) {
+    return next();
+  }
+  
+  const now = Date.now();
+  const windowMs = 60000; // 1 минута
+  const maxRequests = 10; // 10 запросов в минуту
+  
+  if (!userRequests.has(userId)) {
+    userRequests.set(userId, []);
+  }
+  
+  const requests = userRequests.get(userId);
+  
+  // Очищаем старые запросы за пределами окна
+  const recentRequests = requests.filter(time => now - time < windowMs);
+  
+  if (recentRequests.length >= maxRequests) {
+    const oldestRequest = Math.min(...recentRequests);
+    const waitTime = Math.ceil((windowMs - (now - oldestRequest)) / 1000);
+    
+    logger.warn({ userId, waitTime }, 'Rate limit exceeded');
+    
+    await ctx.reply(
+      `⚠️ Слишком много запросов. Пожалуйста, подождите ${waitTime} сек.`
+    );
+    
+    return;
+  }
+  
+  // Добавляем текущий запрос
+  recentRequests.push(now);
+  userRequests.set(userId, recentRequests);
+  
+  return next();
+}
+
+/**
+ * Сброс rate limiting для пользователя
+ * @param {number} userId
+ */
+function resetRateLimit(userId) {
+  userRequests.delete(userId);
+}
+
+/**
+ * Очистка всех rate limit данных
+ */
+function clearRateLimits() {
+  userRequests.clear();
+}
+
+module.exports = {
+  rateLimitMiddleware,
+  resetRateLimit,
+  clearRateLimits,
+};

package/src/bot/middleware/session.js

@@ -0,0 +1,63 @@
+const sessionService = require('../../services/db/sessions');
+const { logger } = require('../../utils/logger');
+
+/**
+ * Middleware для управления сессиями
+ * Автоматически очищает просроченные сессии раз в час
+ * @param {import('telegraf').Context} ctx
+ * @param {Function} next
+ */
+async function sessionMiddleware(ctx, next) {
+  const userId = ctx.from?.id;
+  const chatId = ctx.chat?.id;
+  
+  if (!userId || !chatId) {
+    return next();
+  }
+  
+  // Очистка просроченных сессий (раз в час)
+  const lastCleanup = ctx.botInfo?.last_cleanup || 0;
+  const now = Date.now();
+  
+  if (now - lastCleanup > 3600000) { // 1 час
+    const removed = sessionService.cleanupExpired();
+    logger.info({ removed }, 'Expired sessions cleaned up');
+    ctx.botInfo = { ...ctx.botInfo, last_cleanup: now };
+  }
+  
+  // Поиск активной сессии для текущего чата
+  const isPrivate = chatId > 0 || userId === chatId;
+  
+  if (isPrivate) {
+    // Личный чат - одна сессия на пользователя
+    const sessionKey = `user:${userId}`;
+    const session = sessionService.getByKey(sessionKey);
+    
+    if (session && session.status === 'active') {
+      ctx.state.session = session;
+      ctx.state.sessionKey = sessionKey;
+    }
+  } else {
+    // Групповой чат - поиск сессии по reply
+    const replyToMessageId = ctx.message?.reply_to_message?.message_id;
+    
+    if (replyToMessageId) {
+      // Поиск сессии по сообщению, на которое ответили
+      const session = sessionService.findByMessage(chatId, replyToMessageId);
+      
+      if (session) {
+        ctx.state.session = session;
+        ctx.state.sessionKey = `chat:${chatId}`;
+        ctx.state.replyToSession = true;
+      }
+    }
+  }
+  
+  ctx.state.isPrivate = isPrivate;
+  ctx.state.userId = userId;
+  ctx.state.chatId = chatId;
+  
+  return next();
+}
+
+module.exports = { sessionMiddleware };

package/src/config/index.js

@@ -0,0 +1,57 @@
+require('dotenv').config();
+
+/**
+ * Конфигурация приложения
+ * Загружает значения из переменных окружения с fallback на значения по умолчанию
+ */
+module.exports = {
+  /** Настройки бота */
+  bot: {
+    /** Telegram Bot API токен */
+    token: process.env.BOT_TOKEN,
+    /** Уровень логирования */
+    logLevel: process.env.LOG_LEVEL || 'info',
+    /** Whitelist пользователей (опционально) */
+    allowedUsers: process.env.ALLOWED_USERS
+      ? process.env.ALLOWED_USERS.split(',').map(Number).filter(Boolean)
+      : [],
+  },
+  
+  /** Настройки Qwen Code */
+  qwen: {
+    /** Таймаут выполнения команды (мс) */
+    timeout: parseInt(process.env.QWEN_TIMEOUT, 10) || 60000,
+    /** Максимальный размер буфера (байты) */
+    maxBuffer: parseInt(process.env.QWEN_MAX_BUFFER, 10) || 2 * 1024 * 1024, // 2MB
+    /** Максимальный размер файла для анализа (байты) */
+    maxFileSize: 2 * 1024 * 1024, // 2MB
+  },
+  
+  /** Rate limiting */
+  rateLimit: {
+    /** Окно времени (мс) */
+    windowMs: parseInt(process.env.RATE_LIMIT_WINDOW, 10) || 60000, // 1 минута
+    /** Максимум запросов в окно */
+    maxRequests: parseInt(process.env.RATE_LIMIT_MAX, 10) || 10,
+  },
+  
+  /** Сессии */
+  session: {
+    /** Срок жизни сессии (часы) */
+    timeoutHours: 24,
+    /** Максимум сообщений в сессии */
+    maxMessages: 1000,
+  },
+  
+  /** Логирование */
+  logging: {
+    /** Ротация логов (дни) */
+    rotationDays: 1,
+  },
+  
+  /** Пути */
+  paths: {
+    /** Домашняя директория ~/.qwen-alpha */
+    home: null, // Заполняется при инициализации
+  },
+};