qwen-alpha 1.0.0

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "qwen-alpha",
+  "version": "1.0.0",
+  "description": "Telegram bot for Qwen Code integration — AI-powered code review, bug detection, and code generation",
+  "main": "src/index.js",
+  "bin": {
+    "qwen-alpha": "./bin/qwen-alpha.js"
+  },
+  "scripts": {
+    "start": "node bin/qwen-alpha.js",
+    "test": "node --test tests/",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check ."
+  },
+  "keywords": [
+    "telegram",
+    "bot",
+    "qwen",
+    "code",
+    "ai",
+    "cli",
+    "code-review",
+    "assistant"
+  ],
+  "author": "JeBance",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JeBance/QwenAlpha.git"
+  },
+  "bugs": {
+    "url": "https://github.com/JeBance/QwenAlpha/issues"
+  },
+  "homepage": "https://github.com/JeBance/QwenAlpha#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "telegraf": "^4.16.3",
+    "commander": "^11.1.0",
+    "dotenv": "^16.3.1",
+    "pino": "^8.17.2",
+    "pino-pretty": "^10.2.3"
+  },
+  "devDependencies": {
+    "eslint": "^8.56.0",
+    "prettier": "^3.1.1"
+  }
+}

package/src/bot/bot.js

@@ -0,0 +1,81 @@
+const { Telegraf } = require('telegraf');
+const { message } = require('telegraf/filters');
+const { logger } = require('../utils/logger');
+const { loggingMiddleware } = require('./middleware/logging');
+const { rateLimitMiddleware } = require('./middleware/rateLimit');
+const { sessionMiddleware } = require('./middleware/session');
+const { authMiddleware } = require('./middleware/auth');
+
+// Handlers
+const startHandler = require('./handlers/start');
+const helpHandler = require('./handlers/help');
+const resetHandler = require('./handlers/reset');
+const statsHandler = require('./handlers/stats');
+const settingsHandler = require('./handlers/settings');
+const adminHandler = require('./handlers/admin');
+const messageHandler = require('./handlers/message');
+const fileHandler = require('./handlers/file');
+
+/**
+ * Инициализация Telegraf бота
+ * @param {string} token - Telegram Bot API токен
+ * @param {Object} config - Конфигурация
+ * @returns {Promise<import('telegraf').Telegraf>} Бот
+ */
+async function initBot(token, config = {}) {
+  const bot = new Telegraf(token, {
+    handlerTimeout: 30, // Таймаут обработки (секунды)
+  });
+  
+  // Глобальная обработка ошибок
+  bot.catch((err, ctx) => {
+    logger.error({
+      err,
+      userId: ctx?.from?.id,
+      chatId: ctx?.chat?.id,
+      updateType: ctx?.updateType,
+    }, 'Bot error caught');
+    
+    // Не показываем пользователю технические детали
+    if (ctx && ctx.reply) {
+      ctx.reply('⚠️ Произошла ошибка. Попробуйте позже.').catch(() => {});
+    }
+  });
+  
+  // Middleware
+  bot.use(loggingMiddleware);
+  bot.use(rateLimitMiddleware);
+  bot.use(authMiddleware);
+  bot.use(sessionMiddleware);
+  
+  // Commands
+  bot.command('start', startHandler);
+  bot.command('help', helpHandler);
+  bot.command('reset', resetHandler);
+  bot.command('stats', statsHandler);
+  bot.command('settings', settingsHandler);
+  bot.command('admin', adminHandler);
+  
+  // Сообщения
+  bot.on(message('text'), messageHandler);
+  bot.on(message('document'), fileHandler);
+  bot.on(message('photo'), fileHandler);
+  
+  // Упоминания бота (для групповых чатов)
+  bot.on('message', async (ctx, next) => {
+    const botInfo = await bot.telegram.getMe();
+    const botUsername = `@${botInfo.username}`;
+    
+    if (ctx.message.text?.includes(botUsername)) {
+      return messageHandler(ctx);
+    }
+    
+    return next();
+  });
+  
+  logger.info('Bot initialized with middleware and handlers');
+  
+  return bot;
+}
+
+module.exports = { initBot };

package/src/bot/handlers/admin.js

@@ -0,0 +1,231 @@
+const adminService = require('../../services/db/admins');
+const userService = require('../../services/db/users');
+const sessionService = require('../../services/db/sessions');
+const statsService = require('../../services/db/stats');
+const { storeManager } = require('../../services/db');
+const { logger } = require('../../utils/logger');
+
+/**
+ * Обработчик команды /admin
+ * Панель администратора
+ * @param {import('telegraf').Context} ctx
+ */
+async function adminHandler(ctx) {
+  const userId = ctx.state.userId;
+  const args = ctx.message?.text?.split(' ').slice(1) || [];
+  const command = args[0]?.toLowerCase();
+  
+  // Проверка прав администратора
+  if (!ctx.state.isAdmin) {
+    await ctx.reply('⛔ Доступ запрещён. Требуются права администратора.');
+    logger.warn({ userId }, 'Non-admin tried to access /admin');
+    return;
+  }
+  
+  // Без подкоманды — показать меню
+  if (!command) {
+    const admins = adminService.getAllAdmins();
+    const globalStats = statsService.getGlobal();
+    
+    const menuText = `
+🛡 **Панель администратора**
+
+**Администраторы:**
+• Супер-админ: ${admins.super_admin}
+• Обычные админы: ${admins.admins.length}
+
+**Глобальная статистика:**
+• Пользователей: ${globalStats.total_users}
+• Активных за 24ч: ${globalStats.active_24h}
+• Запросов сегодня: ${globalStats.requests_today}
+• Ошибок за 24ч: ${globalStats.errors_24h}
+
+---
+**Команды:**
+
+**Управление админами:**
+/admin add <user_id> — добавить админа
+/admin remove <user_id> — удалить админа
+
+**Управление пользователями:**
+/admin ban <user_id> — забанить
+/admin unban <user_id> — разбанить
+
+**Сессии:**
+/admin sessions list — список сессий
+/admin sessions close <session_id> — закрыть
+/admin sessions clear <chat_id> — очистить чат
+
+**Настройки:**
+/admin set <key> <value> — изменить настройку
+/admin settings — показать настройки
+
+**Статистика:**
+/admin stats — подробная статистика
+/admin broadcast <message> — рассылка всем
+    `.trim();
+    
+    await ctx.reply(menuText, { parse_mode: 'Markdown' });
+    return;
+  }
+  
+  // Обработка подкоманд
+  switch (command) {
+    case 'add': {
+      const targetId = parseInt(args[1], 10);
+      if (!targetId || isNaN(targetId)) {
+        await ctx.reply('❌ Usage: /admin add <user_id>');
+        return;
+      }
+      
+      const success = adminService.addAdmin(targetId, userId);
+      if (success) {
+        await ctx.reply(`✅ Пользователь ${targetId} добавлен в админы.`);
+        logger.info({ userId, targetId }, 'Admin added');
+      } else {
+        await ctx.reply('❌ Не удалось добавить админа.');
+      }
+      break;
+    }
+    
+    case 'remove': {
+      const targetId = parseInt(args[1], 10);
+      if (!targetId || isNaN(targetId)) {
+        await ctx.reply('❌ Usage: /admin remove <user_id>');
+        return;
+      }
+      
+      const success = adminService.removeAdmin(targetId, userId);
+      if (success) {
+        await ctx.reply(`✅ Пользователь ${targetId} удалён из админов.`);
+        logger.info({ userId, targetId }, 'Admin removed');
+      } else {
+        await ctx.reply('❌ Не удалось удалить админа.');
+      }
+      break;
+    }
+    
+    case 'ban': {
+      const targetId = parseInt(args[1], 10);
+      if (!targetId || isNaN(targetId)) {
+        await ctx.reply('❌ Usage: /admin ban <user_id>');
+        return;
+      }
+      
+      const success = userService.ban(targetId);
+      if (success) {
+        await ctx.reply(`✅ Пользователь ${targetId} забанен.`);
+        logger.info({ userId, targetId }, 'User banned');
+      } else {
+        await ctx.reply('❌ Пользователь не найден.');
+      }
+      break;
+    }
+    
+    case 'unban': {
+      const targetId = parseInt(args[1], 10);
+      if (!targetId || isNaN(targetId)) {
+        await ctx.reply('❌ Usage: /admin unban <user_id>');
+        return;
+      }
+      
+      const success = userService.unban(targetId);
+      if (success) {
+        await ctx.reply(`✅ Пользователь ${targetId} разбанен.`);
+        logger.info({ userId, targetId }, 'User unbanned');
+      } else {
+        await ctx.reply('❌ Пользователь не найден.');
+      }
+      break;
+    }
+    
+    case 'sessions': {
+      const subCommand = args[2];
+      
+      if (subCommand === 'list') {
+        const allSessions = sessionService._store.getData();
+        const sessionCount = Object.keys(allSessions).length;
+        await ctx.reply(`📊 Всего сессий: ${sessionCount}`);
+      } else if (subCommand === 'clear') {
+        const chatId = parseInt(args[3], 10);
+        if (!chatId) {
+          await ctx.reply('❌ Usage: /admin sessions clear <chat_id>');
+          return;
+        }
+        
+        const data = sessionService._store.getData();
+        delete data[`chat:${chatId}`];
+        sessionService._store.setData(data);
+        
+        await ctx.reply(`✅ Сессии чата ${chatId} очищены.`);
+        logger.info({ userId, chatId }, 'Chat sessions cleared');
+      } else {
+        await ctx.reply('❌ Usage: /admin sessions list | clear <chat_id>');
+      }
+      break;
+    }
+    
+    case 'set': {
+      const key = args[1];
+      const value = args[2];
+      
+      if (!key || value === undefined) {
+        await ctx.reply('❌ Usage: /admin set <key> <value>');
+        return;
+      }
+      
+      const settings = storeManager.get('settings');
+      const data = settings.getData();
+      
+      // Преобразование значения
+      let parsedValue = value;
+      if (!isNaN(Number(value))) {
+        parsedValue = Number(value);
+      } else if (value.toLowerCase() === 'true') {
+        parsedValue = true;
+      } else if (value.toLowerCase() === 'false') {
+        parsedValue = false;
+      }
+      
+      if (data.hasOwnProperty(key)) {
+        data[key] = parsedValue;
+        settings.setData(data);
+        await ctx.reply(`✅ Настройка '${key}' установлена в '${parsedValue}'.`);
+        logger.info({ userId, key, value: parsedValue }, 'Setting updated');
+      } else {
+        await ctx.reply(`❌ Настройка '${key}' не найдена.`);
+      }
+      break;
+    }
+    
+    case 'settings': {
+      const settings = storeManager.get('settings').getData();
+      const settingsText = Object.entries(settings)
+        .map(([key, value]) => `• ${key}: ${value}`)
+        .join('\n');
+      
+      await ctx.reply(`⚙️ **Настройки бота:**\n\n${settingsText}`, { parse_mode: 'Markdown' });
+      break;
+    }
+    
+    case 'stats': {
+      const periodStats = statsService.getPeriod(7);
+      const statsText = `
+📊 **Статистика за 7 дней:**
+
+**Запросы:** ${periodStats.total_requests}
+**Ошибки:** ${periodStats.total_errors}
+**Файлы:** ${periodStats.total_files}
+**Сессии:** ${periodStats.total_sessions}
+      `.trim();
+      
+      await ctx.reply(statsText, { parse_mode: 'Markdown' });
+      break;
+    }
+    
+    default:
+      await ctx.reply('❌ Неизвестная команда. Используйте /admin для просмотра меню.');
+  }
+}
+
+module.exports = adminHandler;

package/src/bot/handlers/file.js

@@ -0,0 +1,177 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const sessionService = require('../../services/db/sessions');
+const statsService = require('../../services/db/stats');
+const userService = require('../../services/db/users');
+const { qwenService } = require('../../services/qwenService');
+const config = require('../../config');
+const { logger } = require('../../utils/logger');
+
+/**
+ * Обработчик файлов (документы и фото)
+ * @param {import('telegraf').Context} ctx
+ */
+async function fileHandler(ctx) {
+  const userId = ctx.state.userId;
+  const chatId = ctx.state.chatId;
+  const isPrivate = ctx.state.isPrivate;
+  
+  // Получение файла из сообщения
+  let fileId;
+  let fileName = 'unknown';
+  let fileSize = 0;
+  
+  if (ctx.message.document) {
+    fileId = ctx.message.document.file_id;
+    fileName = ctx.message.document.file_name || 'code.txt';
+    fileSize = ctx.message.document.file_size || 0;
+  } else if (ctx.message.photo && ctx.message.photo.length > 0) {
+    // Берём фото наилучшего качества
+    const photo = ctx.message.photo[ctx.message.photo.length - 1];
+    fileId = photo.file_id;
+    fileName = 'image.jpg';
+    fileSize = photo.file_size || 0;
+  } else {
+    return;
+  }
+  
+  // Проверка размера файла
+  const maxFileSize = config.qwen.maxFileSize;
+  if (fileSize > maxFileSize) {
+    const maxMB = (maxFileSize / 1024 / 1024).toFixed(2);
+    await ctx.reply(
+      `❌ Файл слишком большой. Максимальный размер: ${maxMB}MB`,
+      { reply_parameters: { message_id: ctx.message.message_id } }
+    );
+    return;
+  }
+  
+  // Загрузка индикатора
+  const loadingMsg = await ctx.reply('⏳ Скачиваю и анализирую файл...');
+  
+  let tempFilePath = null;
+  
+  try {
+    const startTime = Date.now();
+    
+    // Скачивание файла
+    const fileLink = await ctx.telegram.getFileLink(fileId);
+    const response = await fetch(fileLink.href);
+    
+    if (!response.ok) {
+      throw new Error('Failed to download file');
+    }
+    
+    // Сохранение во временный файл
+    tempFilePath = path.join(os.tmpdir(), `qwen-alpha-${Date.now()}-${fileName}`);
+    const buffer = Buffer.from(await response.arrayBuffer());
+    fs.writeFileSync(tempFilePath, buffer);
+    
+    // Чтение содержимого (для текстовых файлов)
+    let fileContent;
+    try {
+      fileContent = fs.readFileSync(tempFilePath, 'utf-8');
+    } catch (readError) {
+      throw new Error('Не удалось прочитать файл. Поддерживаются только текстовые файлы.');
+    }
+    
+    // Проверка размера содержимого
+    if (fileContent.length > maxFileSize) {
+      await ctx.editMessageText(
+        `❌ Содержимое файла слишком большое. Максимум: ${maxFileSize} символов.`
+      );
+      return;
+    }
+    
+    // Получение контекста из сессии
+    let contextMessages = [];
+    const session = ctx.state.session;
+    
+    if (session) {
+      const replyToMessageId = ctx.message?.reply_to_message?.message_id;
+      if (replyToMessageId && session.message_tree[replyToMessageId]) {
+        contextMessages = sessionService.getMessageChain(session, replyToMessageId);
+      }
+    }
+    
+    // Формирование промпта для анализа файла
+    const prompt = `Проанализируй этот файл (${fileName}):\n\n${fileContent}`;
+    
+    // Запрос к Qwen
+    const result = await qwenService.analyzeCode(prompt, contextMessages);
+    
+    const duration = Date.now() - startTime;
+    statsService.updateAvgResponseTime(duration);
+    
+    // Отправка ответа (разбиваем на части если длинный)
+    const maxMessageLength = 4096;
+    const chunks = splitMessage(result, maxMessageLength);
+    
+    for (let i = 0; i < chunks.length; i++) {
+      if (i === 0 && loadingMsg) {
+        await ctx.editMessageText(chunks[i], { parse_mode: 'Markdown' });
+      } else {
+        await ctx.reply(chunks[i], { parse_mode: 'Markdown' });
+      }
+    }
+    
+    // Обновление статистики
+    statsService.incrementRequest();
+    statsService.incrementFile();
+    userService.incrementRequest(userId);
+    userService.updateStats(userId, {
+      total_files: (userService.getById(userId)?.stats?.total_files || 0) + 1,
+    });
+    
+    logger.info({ userId, chatId, fileName, fileSize, duration }, 'File analyzed');
+    
+  } catch (error) {
+    logger.error({ userId, chatId, fileName, error }, 'File analysis failed');
+    
+    await ctx.editMessageText(
+      `❌ Ошибка при анализе файла: ${error.message}`
+    );
+    
+    statsService.incrementError();
+  } finally {
+    // Очистка временного файла
+    if (tempFilePath && fs.existsSync(tempFilePath)) {
+      try {
+        fs.unlinkSync(tempFilePath);
+      } catch (e) {
+        logger.warn({ tempFilePath }, 'Failed to delete temp file');
+      }
+    }
+  }
+}
+
+/**
+ * Разбиение длинного сообщения на части
+ * @param {string} text - Текст для разбиения
+ * @param {number} maxLength - Максимальная длина
+ * @returns {string[]} Массив частей
+ */
+function splitMessage(text, maxLength) {
+  const chunks = [];
+  let currentChunk = '';
+  
+  const lines = text.split('\n');
+  
+  for (const line of lines) {
+    if (currentChunk.length + line.length + 1 > maxLength) {
+      chunks.push(currentChunk);
+      currentChunk = line;
+    } else {
+      currentChunk += (currentChunk ? '\n' : '') + line;
+    }
+  }
+  
+  if (currentChunk) {
+    chunks.push(currentChunk);
+  }
+  
+  return chunks;
+}
+
+module.exports = fileHandler;

package/src/bot/handlers/help.js

@@ -0,0 +1,43 @@
+/**
+ * Обработчик команды /help
+ * Список команд и информация о боте
+ * @param {import('telegraf').Context} ctx
+ */
+async function helpHandler(ctx) {
+  const isAdmin = ctx.state.isAdmin;
+  
+  const helpText = `
+📖 **Qwen Alpha — Команды бота**
+
+**Основные команды:**
+/start — Запуск бота и приветствие
+/help — Эта справка
+/reset — Сброс текущей сессии
+/stats — Ваша статистика
+/settings — Настройки бота
+
+**Работа с кодом:**
+• Отправьте код текстом — я проанализирую его
+• Отправьте файл с кодом — я изучу и дам рекомендации
+• В группах: /qwen <запрос> или @QwenAlphaRobot <запрос>
+• Ответьте на сообщение бота — продолжим диалог
+
+**Для групповых чатов:**
+1. Начните сессию: /qwen Как сделать аутентификацию?
+2. Продолжайте ответами на сообщения — я помню контекст
+3. Каждая тема — отдельное дерево сообщений
+
+${isAdmin ? '**Админ команды:**\n/admin — Панель администратора\n\n' : ''}
+🔗 **Репозиторий:** https://github.com/JeBance/QwenAlpha
+📝 **Документация:** https://github.com/JeBance/QwenAlpha#readme
+
+**Технологии:**
+• Qwen Code (headless режим)
+• Telegraf (Node.js)
+• JSON хранилище (~/.qwen-alpha/)
+  `.trim();
+  
+  await ctx.reply(helpText, { parse_mode: 'Markdown' });
+}
+
+module.exports = helpHandler;