qwen-alpha 1.0.0

package/src/services/db/users.js

@@ -0,0 +1,215 @@
+const { storeManager } = require('./index');
+const { logger } = require('../../utils/logger');
+
+/**
+ * Сервис для управления пользователями
+ */
+class UserService {
+  /**
+   * Получение хранилища пользователей
+   * @private
+   */
+  get _store() {
+    return storeManager.get('users');
+  }
+  
+  /**
+   * Получение пользователя по ID
+   * @param {number} userId - Telegram user ID
+   * @returns {Object|null} Данные пользователя или null
+   */
+  getById(userId) {
+    const data = this._store.getData();
+    return data[userId] || null;
+  }
+  
+  /**
+   * Создание или обновление пользователя
+   * @param {Object} userData - Данные пользователя
+   * @param {number} userData.id - Telegram user ID
+   * @param {string} [userData.username] - Username
+   * @param {string} [userData.first_name] - First name
+   * @param {string} [userData.last_name] - Last name
+   * @returns {Object} Данные пользователя
+   */
+  upsert(userData) {
+    const data = this._store.getData();
+    const now = new Date().toISOString();
+    
+    const existingUser = data[userData.id];
+    
+    data[userData.id] = {
+      id: userData.id,
+      username: userData.username || null,
+      first_name: userData.first_name || null,
+      last_name: userData.last_name || null,
+      created_at: existingUser?.created_at || now,
+      last_seen: now,
+      settings: {
+        model: 'qwen3-coder-plus',
+        language: 'ru',
+        notifications: true,
+        requests_per_hour: 60,
+        ...existingUser?.settings,
+      },
+      stats: {
+        total_requests: existingUser?.stats?.total_requests || 0,
+        total_files: existingUser?.stats?.total_files || 0,
+        total_tokens: existingUser?.stats?.total_tokens || 0,
+        groups_used: existingUser?.stats?.groups_used || 0,
+      },
+      rate_limits: {
+        requests_today: existingUser?.rate_limits?.requests_today || 0,
+        last_request: existingUser?.rate_limits?.last_request || null,
+      },
+      is_banned: existingUser?.is_banned || false,
+    };
+    
+    this._store.setData(data);
+    logger.debug({ userId: userData.id }, 'User upserted');
+    
+    return data[userData.id];
+  }
+  
+  /**
+   * Обновление настроек пользователя
+   * @param {number} userId - Telegram user ID
+   * @param {Object} settings - Новые настройки
+   * @returns {Object} Обновлённые данные пользователя
+   */
+  updateSettings(userId, settings) {
+    const data = this._store.getData();
+    
+    if (!data[userId]) {
+      throw new Error(`User ${userId} not found`);
+    }
+    
+    data[userId].settings = {
+      ...data[userId].settings,
+      ...settings,
+    };
+    
+    this._store.setData(data);
+    logger.debug({ userId, settings }, 'User settings updated');
+    
+    return data[userId];
+  }
+  
+  /**
+   * Бан пользователя
+   * @param {number} userId - Telegram user ID
+   * @returns {boolean} Успешность операции
+   */
+  ban(userId) {
+    const data = this._store.getData();
+    
+    if (!data[userId]) {
+      return false;
+    }
+    
+    data[userId].is_banned = true;
+    this._store.setData(data);
+    logger.warn({ userId }, 'User banned');
+    
+    return true;
+  }
+  
+  /**
+   * Разбан пользователя
+   * @param {number} userId - Telegram user ID
+   * @returns {boolean} Успешность операции
+   */
+  unban(userId) {
+    const data = this._store.getData();
+    
+    if (!data[userId]) {
+      return false;
+    }
+    
+    data[userId].is_banned = false;
+    this._store.setData(data);
+    logger.info({ userId }, 'User unbanned');
+    
+    return true;
+  }
+  
+  /**
+   * Обновление статистики пользователя
+   * @param {number} userId - Telegram user ID
+   * @param {Object} updates - Обновления статистики
+   * @returns {Object} Обновлённые данные пользователя
+   */
+  updateStats(userId, updates) {
+    const data = this._store.getData();
+    
+    if (!data[userId]) {
+      throw new Error(`User ${userId} not found`);
+    }
+    
+    data[userId].stats = {
+      ...data[userId].stats,
+      ...updates,
+    };
+    
+    this._store.setData(data);
+    return data[userId];
+  }
+  
+  /**
+   * Increment запроса пользователя
+   * @param {number} userId - Telegram user ID
+   */
+  incrementRequest(userId) {
+    const data = this._store.getData();
+    const today = new Date().toISOString().split('T')[0];
+    
+    if (!data[userId]) {
+      return;
+    }
+    
+    // Сброс счётчика если новый день
+    const lastRequest = data[userId].rate_limits?.last_request;
+    if (lastRequest && lastRequest.split('T')[0] !== today) {
+      data[userId].rate_limits.requests_today = 0;
+    }
+    
+    data[userId].rate_limits = {
+      requests_today: (data[userId].rate_limits?.requests_today || 0) + 1,
+      last_request: new Date().toISOString(),
+    };
+    
+    data[userId].stats.total_requests = (data[userId].stats?.total_requests || 0) + 1;
+    
+    this._store.setData(data);
+  }
+  
+  /**
+   * Получение всех пользователей
+   * @returns {Array} Массив пользователей
+   */
+  getAll() {
+    const data = this._store.getData();
+    return Object.values(data);
+  }
+  
+  /**
+   * Удаление пользователя
+   * @param {number} userId - Telegram user ID
+   * @returns {boolean} Успешность операции
+   */
+  delete(userId) {
+    const data = this._store.getData();
+    
+    if (!data[userId]) {
+      return false;
+    }
+    
+    delete data[userId];
+    this._store.setData(data);
+    logger.info({ userId }, 'User deleted');
+    
+    return true;
+  }
+}
+
+module.exports = new UserService();

package/src/services/qwenService.js

@@ -0,0 +1,254 @@
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const { logger } = require('../utils/logger');
+const config = require('../config');
+
+const execAsync = promisify(exec);
+
+/**
+ * Класс ошибки Qwen
+ */
+class QwenError extends Error {
+  constructor(message, cause = null, code = null) {
+    super(message);
+    this.name = 'QwenError';
+    this.cause = cause;
+    this.code = code;
+  }
+}
+
+/**
+ * Сервис для работы с Qwen Code в headless режиме
+ */
+class QwenService {
+  /**
+   * Экранирование строки для shell
+   * @param {string} str - Строка для экранирования
+   * @returns {string} Экранированная строка
+   * @private
+   */
+  _escapeShell(str) {
+    if (typeof str !== 'string') {
+      return '';
+    }
+    // Экранирование специальных символов
+    return str.replace(/'/g, "'\\''").replace(/"/g, '\\"').replace(/`/g, '\\`');
+  }
+  
+  /**
+   * Проверка доступности Qwen Code
+   * @returns {Promise<boolean>} true если Qwen доступен
+   */
+  async checkAvailability() {
+    try {
+      const { stdout } = await execAsync('qwen --version', {
+        timeout: 5000,
+      });
+      logger.info({ version: stdout.trim() }, 'Qwen Code available');
+      return true;
+    } catch (error) {
+      logger.warn({ error: error.message }, 'Qwen Code not available');
+      return false;
+    }
+  }
+  
+  /**
+   * Анализ кода через Qwen Code headless
+   * @param {string} code - Код для анализа
+   * @param {Array} [contextMessages] - Контекстные сообщения для истории диалога
+   * @returns {Promise<string>} Ответ от Qwen
+   * @throws {QwenError} Ошибка при анализе
+   */
+  async analyzeCode(code, contextMessages = []) {
+    const startTime = Date.now();
+    
+    // Проверка доступности Qwen
+    const isAvailable = await this.checkAvailability();
+    if (!isAvailable) {
+      throw new QwenError(
+        'Qwen Code не установлен. Установите: npm install -g @qwen-code/qwen-code',
+        null,
+        'QWEN_NOT_INSTALLED'
+      );
+    }
+    
+    // Формирование промпта с контекстом
+    let fullPrompt = code;
+    
+    if (contextMessages && contextMessages.length > 0) {
+      // Добавляем контекст диалога
+      const contextText = contextMessages
+        .map(msg => `${msg.role === 'assistant' ? 'Assistant' : 'User'}: ${msg.content}`)
+        .join('\n');
+      
+      fullPrompt = `${contextText}\n\nUser: ${code}`;
+    }
+    
+    // Команда для Qwen
+    const escapedPrompt = this._escapeShell(fullPrompt);
+    const command = `echo '${escapedPrompt}' | qwen -p "Проанализируй код и дай рекомендации" -o json`;
+    
+    logger.debug({ codeLength: code.length, contextLength: contextMessages.length }, 'Running Qwen analysis');
+    
+    try {
+      const { stdout, stderr } = await execAsync(command, {
+        timeout: config.qwen.timeout,
+        maxBuffer: config.qwen.maxBuffer,
+        env: { ...process.env },
+      });
+      
+      // Парсинг JSON ответа
+      const result = this._parseJsonResponse(stdout);
+      
+      const duration = Date.now() - startTime;
+      logger.info({ duration, resultLength: result.length }, 'Qwen analysis completed');
+      
+      return result;
+      
+    } catch (error) {
+      logger.error({ error, stderr }, 'Qwen analysis failed');
+      
+      // Обработка различных типов ошибок
+      if (error.killed && error.signal === 'SIGTERM') {
+        throw new QwenError(
+          'Анализ прерван по таймауту. Попробуйте с меньшим файлом.',
+          error,
+          'TIMEOUT'
+        );
+      }
+      
+      if (error.message.includes('maxBuffer')) {
+        throw new QwenError(
+          'Ответ слишком большой. Попробуйте меньший фрагмент кода.',
+          error,
+          'BUFFER_EXCEEDED'
+        );
+      }
+      
+      throw new QwenError(
+        `Ошибка Qwen Code: ${error.message}`,
+        error,
+        'QWEN_ERROR'
+      );
+    }
+  }
+  
+  /**
+   * Парсинг JSON ответа от Qwen
+   * @param {string} stdout - JSON строка от Qwen
+   * @returns {string} Извлечённый текст ответа
+   * @private
+   */
+  _parseJsonResponse(stdout) {
+    try {
+      const messages = JSON.parse(stdout.trim());
+      
+      if (!Array.isArray(messages)) {
+        logger.warn({ stdout }, 'Unexpected Qwen response format');
+        return stdout.trim();
+      }
+      
+      // Поиск сообщения от assistant
+      const assistantMessage = messages.find(m => m.type === 'assistant');
+      
+      if (assistantMessage?.message?.content) {
+        const content = assistantMessage.message.content;
+        
+        // Content может быть строкой или массивом
+        if (typeof content === 'string') {
+          return content;
+        }
+        
+        if (Array.isArray(content)) {
+          // Объединение текстовых частей
+          return content
+            .filter(part => part.type === 'text')
+            .map(part => part.text)
+            .join('\n');
+        }
+      }
+      
+      // Поиск result сообщения
+      const resultMessage = messages.find(m => m.type === 'result');
+      if (resultMessage?.result) {
+        return resultMessage.result;
+      }
+      
+      // Fallback: возврат всего stdout
+      return stdout.trim();
+      
+    } catch (parseError) {
+      logger.warn({ parseError, stdout }, 'Failed to parse Qwen JSON response');
+      return stdout.trim();
+    }
+  }
+  
+  /**
+   * Генерация кода по описанию
+   * @param {string} description - Описание того, что нужно сгенерировать
+   * @param {string} [language] - Язык программирования
+   * @returns {Promise<string>} Сгенерированный код
+   */
+  async generateCode(description, language = null) {
+    const prompt = language
+      ? `Напиши код на ${language}: ${description}`
+      : `Напиши код: ${description}`;
+    
+    return this.analyzeCode(prompt);
+  }
+  
+  /**
+   * Code review кода
+   * @param {string} code - Код для ревью
+   * @param {string} [focus] - На чём сосредоточиться (security, performance, style)
+   * @returns {Promise<string>} Результат ревью
+   */
+  async reviewCode(code, focus = null) {
+    let prompt = 'Сделай code review этого кода. Найди баги, уязвимости и предложи улучшения.\n\n';
+    
+    if (focus) {
+      prompt += `Сосредоточься на: ${focus}.\n\n`;
+    }
+    
+    prompt += code;
+    
+    return this.analyzeCode(prompt);
+  }
+  
+  /**
+   * Объяснение кода
+   * @param {string} code - Код для объяснения
+   * @returns {Promise<string>} Объяснение
+   */
+  async explainCode(code) {
+    const prompt = `Объясни подробно, что делает этот код:\n\n${code}`;
+    return this.analyzeCode(prompt);
+  }
+  
+  /**
+   * Рефакторинг кода
+   * @param {string} code - Код для рефакторинга
+   * @param {string} [goal] - Цель рефакторинга
+   * @returns {Promise<string>} Рефакторированный код
+   */
+  async refactorCode(code, goal = null) {
+    let prompt = 'Рефактори этот код, улучши читаемость и производительность.\n\n';
+    
+    if (goal) {
+      prompt += `Цель: ${goal}.\n\n`;
+    }
+    
+    prompt += code;
+    
+    return this.analyzeCode(prompt);
+  }
+}
+
+// Экспорт синглтона
+const qwenService = new QwenService();
+
+module.exports = {
+  QwenService,
+  qwenService,
+  QwenError,
+};

package/src/utils/logger.js

@@ -0,0 +1,127 @@
+const pino = require('pino');
+const path = require('path');
+const { DIRECTORIES, getLogFilePath } = require('./paths');
+
+/**
+ * Создаёт транспорт для записи логов в файл с ежедневной ротацией
+ */
+function createFileTransport() {
+  return {
+    target: 'pino/file',
+    options: {
+      destination: getLogFilePath(),
+      mkdir: true,
+    },
+  };
+}
+
+/**
+ * Создаёт транспорт для вывода в консоль (pretty)
+ */
+function createPrettyTransport() {
+  return {
+    target: 'pino-pretty',
+    options: {
+      colorize: true,
+      translateTime: 'SYS:standard',
+      ignore: 'pid,hostname',
+    },
+  };
+}
+
+/**
+ * Получает уровень логирования из переменных окружения
+ * @returns {string} Уровень логирования (debug, info, warn, error)
+ */
+function getLogLevel() {
+  const level = process.env.LOG_LEVEL || 'info';
+  const validLevels = ['debug', 'info', 'warn', 'error', 'fatal', 'silent'];
+  return validLevels.includes(level) ? level : 'info';
+}
+
+/**
+ * Создаёт и конфигурирует логгер
+ * @returns {import('pino').Logger} Настроенный логгер Pino
+ */
+function createLogger() {
+  const level = getLogLevel();
+  
+  return pino({
+    level,
+    formatters: {
+      level: (label) => ({ level: label }),
+    },
+    timestamp: pino.stdTimeFunctions.isoTime,
+  }, pino.multistream([
+    createFileTransport(),
+    {
+      stream: process.stdout,
+      level,
+    },
+  ]));
+}
+
+/**
+ * Логгер с добавлением контекста
+ */
+class ContextLogger {
+  constructor(baseLogger, defaultContext = {}) {
+    this.baseLogger = baseLogger;
+    this.defaultContext = defaultContext;
+  }
+  
+  child(context) {
+    return new ContextLogger(
+      this.baseLogger.child(context),
+      { ...this.defaultContext, ...context }
+    );
+  }
+  
+  debug(msg, context = {}) {
+    this.baseLogger.debug({ ...this.defaultContext, ...context }, msg);
+  }
+  
+  info(msg, context = {}) {
+    this.baseLogger.info({ ...this.defaultContext, ...context }, msg);
+  }
+  
+  warn(msg, context = {}) {
+    this.baseLogger.warn({ ...this.defaultContext, ...context }, msg);
+  }
+  
+  error(msg, context = {}) {
+    this.baseLogger.error({ ...this.defaultContext, ...context }, msg);
+  }
+  
+  fatal(msg, context = {}) {
+    this.baseLogger.fatal({ ...this.defaultContext, ...context }, msg);
+  }
+}
+
+// Создаём базовый логгер
+const logger = createLogger();
+
+// Обработчик для ежедневной ротации логов
+function setupLogRotation() {
+  const now = new Date();
+  const tomorrow = new Date(now);
+  tomorrow.setDate(tomorrow.getDate() + 1);
+  tomorrow.setHours(0, 0, 0, 0);
+  
+  const msUntilMidnight = tomorrow.getTime() - now.getTime();
+  
+  // Планируем ротацию на полночь
+  setTimeout(() => {
+    logger.info('Rotating log file');
+    setupLogRotation(); // Планируем следующую ротацию
+  }, msUntilMidnight);
+}
+
+setupLogRotation();
+
+module.exports = {
+  logger,
+  ContextLogger,
+  createLogger,
+  getLogLevel,
+};

package/src/utils/paths.js

@@ -0,0 +1,63 @@
+const path = require('path');
+const os = require('os');
+
+/**
+ * Базовая директория для хранения данных Qwen Alpha
+ * ~/.qwen-alpha/
+ */
+const QWEN_ALPHA_HOME = path.join(os.homedir(), '.qwen-alpha');
+
+/**
+ * Директории для хранения данных
+ */
+const DIRECTORIES = {
+  /** База данных (JSON файлы) */
+  db: path.join(QWEN_ALPHA_HOME, 'db'),
+  /** Логи */
+  logs: path.join(QWEN_ALPHA_HOME, 'logs'),
+  /** Конфигурация */
+  config: path.join(QWEN_ALPHA_HOME, 'config'),
+  /** Временные файлы */
+  temp: path.join(QWEN_ALPHA_HOME, 'temp'),
+};
+
+/**
+ * Файлы базы данных
+ */
+const DB_FILES = {
+  users: path.join(DIRECTORIES.db, 'users.json'),
+  sessions: path.join(DIRECTORIES.db, 'sessions.json'),
+  admins: path.join(DIRECTORIES.db, 'admins.json'),
+  stats: path.join(DIRECTORIES.db, 'stats.json'),
+  settings: path.join(DIRECTORIES.config, 'settings.json'),
+};
+
+/**
+ * Лог файл (с ежедневной ротацией)
+ */
+function getLogFilePath(date = new Date()) {
+  const dateStr = date.toISOString().split('T')[0]; // YYYY-MM-DD
+  return path.join(DIRECTORIES.logs, `qwen-alpha-${dateStr}.log`);
+}
+
+/**
+ * Инициализация директорий
+ * Создаёт все необходимые директории, если они не существуют
+ */
+function initDirectories() {
+  const fs = require('fs');
+  
+  for (const dir of Object.values(DIRECTORIES)) {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+
+module.exports = {
+  QWEN_ALPHA_HOME,
+  DIRECTORIES,
+  DB_FILES,
+  getLogFilePath,
+  initDirectories,
+};