cfix 1.0.0

package/src/queue/integration-example.js

@@ -0,0 +1,283 @@
+/**
+ * 任务队列集成示例
+ *
+ * 这个文件展示如何将任务队列集成到 index.js 中
+ * 不需要修改现有代码，只需添加队列层
+ */
+
+const taskQueue = require('./queue/task-queue');
+const taskManager = require('./task-manager');
+const { logger } = require('./logger');
+
+/**
+ * 初始化任务队列处理器
+ */
+async function initializeQueue() {
+  // 设置队列处理函数
+  taskQueue.process(async (job) => {
+    const { taskId, taskData } = job.data;
+
+    logger.info(`🎯 队列开始处理任务: ${taskId}`);
+
+    try {
+      // 执行实际的修复任务
+      await executeFixTask(taskData);
+
+      logger.info(`✅ 队列任务完成: ${taskId}`);
+    } catch (error) {
+      logger.error(`❌ 队列任务失败: ${taskId}`, error);
+      throw error; // 重新抛出让队列处理重试
+    }
+  });
+
+  logger.info('✅ 任务队列处理器已初始化');
+}
+
+/**
+ * 提交任务到队列（替代直接执行）
+ */
+async function submitTask(taskId, taskData) {
+  try {
+    const queueJob = await taskQueue.addTask({
+      taskId,
+      taskData,
+      priority: taskData.priority || 0,
+    });
+
+    logger.info(`📨 任务已提交到队列: ${taskId} (队列ID: ${queueJob.id})`);
+
+    return {
+      success: true,
+      taskId,
+      queueJobId: queueJob.id,
+      queueType: queueJob.queueType,
+    };
+  } catch (error) {
+    logger.error(`提交任务到队列失败: ${taskId}`, error);
+    throw error;
+  }
+}
+
+/**
+ * 执行实际的修复任务
+ */
+async function executeFixTask(taskData) {
+  const {
+    taskId,
+    requirement,
+    projectPath,
+    repoUrl,
+    runTests,
+    autoPush,
+    aiEngine,
+    baseBranch,
+    createNewBranch,
+    username,
+    mergeToAlpha,
+    mergeToBeta,
+    mergeToMaster,
+  } = taskData;
+
+  // 这里是原有的任务执行逻辑
+  // 从 index.js 的 processFixTask 函数中提取
+
+  try {
+    taskManager.startTask(taskId);
+    taskManager.updateProgress(taskId, 'preparing', '准备项目环境');
+
+    // ... 执行修复逻辑 ...
+
+    taskManager.completeTask(taskId, {
+      success: true,
+      // ... 结果数据 ...
+    });
+
+  } catch (error) {
+    taskManager.failTask(taskId, error);
+    throw error;
+  }
+}
+
+/**
+ * 在 router.post('/api/fix-bug') 中的使用示例
+ */
+function exampleRouteHandler() {
+  router.post("/api/fix-bug", async (ctx) => {
+    try {
+      // 1. 创建任务记录
+      const taskId = taskManager.createTask(
+        sanitizer.sanitizeString(requirement),
+        finalProjectPath,
+        {
+          repoUrl: repoUrl ? sanitizer.sanitizeRepoUrl(repoUrl) : null,
+          runTests,
+          autoPush,
+          aiEngine,
+          baseBranch,
+          createNewBranch,
+          username,
+          mergeToAlpha,
+          mergeToBeta,
+          mergeToMaster,
+        }
+      );
+
+      // 2. 提交到队列（替代原来的 processFixTask(taskId)）
+      const queueResult = await submitTask(taskId, {
+        taskId,
+        requirement,
+        projectPath: finalProjectPath,
+        repoUrl,
+        runTests,
+        autoPush,
+        aiEngine,
+        baseBranch,
+        createNewBranch,
+        username,
+        mergeToAlpha,
+        mergeToBeta,
+        mergeToMaster,
+      });
+
+      // 3. 立即返回响应
+      ctx.body = {
+        success: true,
+        id: taskId,
+        taskId: taskId,
+        message: "任务已加入队列，正在等待处理",
+        statusUrl: `/api/tasks/${taskId}`,
+        queueInfo: {
+          queueJobId: queueResult.queueJobId,
+          queueType: queueResult.queueType,
+        },
+      };
+
+    } catch (error) {
+      logger.error("创建任务失败:", error);
+      ctx.status = 500;
+      ctx.body = {
+        success: false,
+        error: error.message,
+      };
+    }
+  });
+
+  // 新增：查询队列状态接口
+  router.get("/api/queue/stats", async (ctx) => {
+    try {
+      const stats = await taskQueue.getStats();
+
+      ctx.body = {
+        success: true,
+        stats,
+        timestamp: new Date().toISOString(),
+      };
+    } catch (error) {
+      logger.error("获取队列状态失败:", error);
+      ctx.status = 500;
+      ctx.body = {
+        success: false,
+        error: error.message,
+      };
+    }
+  });
+
+  // 新增：清空队列接口（需要认证）
+  router.post("/api/queue/clear", authenticateAPI, async (ctx) => {
+    try {
+      await taskQueue.clear();
+
+      ctx.body = {
+        success: true,
+        message: "队列已清空",
+      };
+    } catch (error) {
+      logger.error("清空队列失败:", error);
+      ctx.status = 500;
+      ctx.body = {
+        success: false,
+        error: error.message,
+      };
+    }
+  });
+
+  // 新增：暂停队列接口（需要认证）
+  router.post("/api/queue/pause", authenticateAPI, async (ctx) => {
+    try {
+      await taskQueue.pause();
+
+      ctx.body = {
+        success: true,
+        message: "队列已暂停",
+      };
+    } catch (error) {
+      logger.error("暂停队列失败:", error);
+      ctx.status = 500;
+      ctx.body = {
+        success: false,
+        error: error.message,
+      };
+    }
+  });
+
+  // 新增：恢复队列接口（需要认证）
+  router.post("/api/queue/resume", authenticateAPI, async (ctx) => {
+    try {
+      await taskQueue.resume();
+
+      ctx.body = {
+        success: true,
+        message: "队列已恢复",
+      };
+    } catch (error) {
+      logger.error("恢复队列失败:", error);
+      ctx.status = 500;
+      ctx.body = {
+        success: false,
+        error: error.message,
+      };
+    }
+  });
+}
+
+/**
+ * 服务启动时初始化队列
+ */
+async function startServer() {
+  // ... 其他初始化代码 ...
+
+  // 初始化任务队列
+  await initializeQueue();
+
+  // ... 启动服务器 ...
+}
+
+/**
+ * 优雅关闭
+ */
+async function gracefulShutdown() {
+  logger.info('📴 开始优雅关闭...');
+
+  try {
+    // 关闭队列
+    await taskQueue.close();
+    logger.info('✅ 队列已关闭');
+
+    // ... 其他清理工作 ...
+
+    process.exit(0);
+  } catch (error) {
+    logger.error('关闭时发生错误:', error);
+    process.exit(1);
+  }
+}
+
+// 监听退出信号
+process.on('SIGTERM', gracefulShutdown);
+process.on('SIGINT', gracefulShutdown);
+
+module.exports = {
+  initializeQueue,
+  submitTask,
+  executeFixTask,
+};

package/src/queue/task-queue.js

@@ -0,0 +1,333 @@
+const { logger } = require('../logger');
+const config = require('../config');
+
+/**
+ * 任务队列管理器
+ * 支持 Redis 队列和本地降级队列
+ */
+class TaskQueue {
+  constructor() {
+    this.redisClient = null;
+    this.localQueue = []; // 本地队列降级方案
+    this.processing = false;
+    this.maxConcurrent = 3; // 最大并发任务数
+    this.currentConcurrent = 0;
+    this.useRedis = false;
+
+    this.initialize();
+  }
+
+  /**
+   * 初始化队列
+   */
+  async initialize() {
+    try {
+      // 尝试连接 Redis
+      const redisConfig = config.get('redis');
+
+      if (redisConfig && redisConfig.host) {
+        await this.initializeRedis(redisConfig);
+      } else {
+        logger.info('📋 未配置 Redis，使用本地任务队列');
+        this.useLocalQueue();
+      }
+    } catch (error) {
+      logger.warn(`⚠️ Redis 连接失败，降级使用本地队列: ${error.message}`);
+      this.useLocalQueue();
+    }
+  }
+
+  /**
+   * 初始化 Redis 队列
+   */
+  async initializeRedis(redisConfig) {
+    try {
+      // 动态加载 Redis 相关依赖
+      const Redis = require('ioredis');
+      const Queue = require('bull');
+
+      // 创建 Redis 客户端
+      this.redisClient = new Redis({
+        host: redisConfig.host,
+        port: redisConfig.port,
+        password: redisConfig.password,
+        retryStrategy: (times) => {
+          if (times > 3) {
+            logger.error('Redis 连接失败次数过多，切换到本地队列');
+            this.useLocalQueue();
+            return null; // 停止重试
+          }
+          return Math.min(times * 1000, 3000);
+        },
+      });
+
+      // 测试连接
+      await this.redisClient.ping();
+
+      // 创建 Bull 队列
+      this.queue = new Queue('auto-fix-tasks', {
+        redis: redisConfig,
+        defaultJobOptions: {
+          attempts: 3,
+          backoff: {
+            type: 'exponential',
+            delay: 2000,
+          },
+          removeOnComplete: 100, // 保留最近 100 个已完成任务
+          removeOnFail: 50, // 保留最近 50 个失败任务
+        },
+      });
+
+      // 监听队列事件
+      this.queue.on('error', (error) => {
+        logger.error('队列错误:', error);
+      });
+
+      this.queue.on('failed', (job, error) => {
+        logger.error(`任务失败: ${job.id}`, error);
+      });
+
+      this.queue.on('completed', (job) => {
+        logger.info(`✅ 队列任务完成: ${job.id}`);
+      });
+
+      this.useRedis = true;
+      logger.info('✅ Redis 队列已启用');
+
+    } catch (error) {
+      if (error.code === 'MODULE_NOT_FOUND') {
+        logger.warn('⚠️ 未安装 Redis 依赖 (ioredis, bull)，使用本地队列');
+      } else {
+        logger.error(`Redis 初始化失败: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * 使用本地队列
+   */
+  useLocalQueue() {
+    this.useRedis = false;
+    this.localQueue = [];
+    logger.info('✅ 本地任务队列已启用');
+
+    // 启动本地队列处理器
+    this.startLocalQueueProcessor();
+  }
+
+  /**
+   * 启动本地队列处理器
+   */
+  startLocalQueueProcessor() {
+    if (this.processing) return;
+
+    this.processing = true;
+
+    // 每秒检查一次队列
+    setInterval(() => {
+      this.processLocalQueue();
+    }, 1000);
+
+    logger.info('🔄 本地队列处理器已启动');
+  }
+
+  /**
+   * 处理本地队列
+   */
+  async processLocalQueue() {
+    // 如果没有待处理任务或并发已满，跳过
+    if (this.localQueue.length === 0 || this.currentConcurrent >= this.maxConcurrent) {
+      return;
+    }
+
+    // 获取队列头部任务
+    const job = this.localQueue.shift();
+
+    if (!job) return;
+
+    this.currentConcurrent++;
+    logger.info(`▶️ 开始处理本地队列任务: ${job.id} (并发: ${this.currentConcurrent}/${this.maxConcurrent})`);
+
+    try {
+      // 执行任务处理函数
+      if (this.processor) {
+        await this.processor(job);
+      }
+    } catch (error) {
+      logger.error(`本地队列任务失败: ${job.id}`, error);
+
+      // 重试逻辑
+      if (job.attempts < 3) {
+        job.attempts++;
+        logger.warn(`重试任务 ${job.id}，第 ${job.attempts} 次尝试`);
+        this.localQueue.push(job); // 重新加入队列尾部
+      }
+    } finally {
+      this.currentConcurrent--;
+    }
+  }
+
+  /**
+   * 添加任务到队列
+   * @param {Object} taskData - 任务数据
+   * @returns {Promise<Object>} 任务信息
+   */
+  async addTask(taskData) {
+    if (this.useRedis && this.queue) {
+      // 使用 Redis 队列
+      try {
+        const job = await this.queue.add(taskData, {
+          priority: taskData.priority || 0,
+        });
+
+        logger.info(`📨 任务已加入 Redis 队列: ${job.id}`);
+
+        return {
+          id: job.id,
+          queueType: 'redis',
+        };
+      } catch (error) {
+        logger.error('Redis 队列添加失败，降级到本地队列:', error);
+        // 降级到本地队列
+        return this.addToLocalQueue(taskData);
+      }
+    } else {
+      // 使用本地队列
+      return this.addToLocalQueue(taskData);
+    }
+  }
+
+  /**
+   * 添加到本地队列
+   */
+  addToLocalQueue(taskData) {
+    const job = {
+      id: `local-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      data: taskData,
+      attempts: 0,
+      createdAt: new Date().toISOString(),
+    };
+
+    this.localQueue.push(job);
+
+    logger.info(`📨 任务已加入本地队列: ${job.id} (队列长度: ${this.localQueue.length})`);
+
+    return {
+      id: job.id,
+      queueType: 'local',
+    };
+  }
+
+  /**
+   * 设置任务处理器
+   * @param {Function} processor - 处理函数 async (job) => {}
+   */
+  process(processor) {
+    this.processor = processor;
+
+    if (this.useRedis && this.queue) {
+      // Redis 队列处理器
+      this.queue.process(this.maxConcurrent, async (job) => {
+        logger.info(`▶️ 开始处理 Redis 队列任务: ${job.id}`);
+        return await processor(job);
+      });
+    }
+    // 本地队列已经在 startLocalQueueProcessor 中处理
+  }
+
+  /**
+   * 获取队列统计信息
+   */
+  async getStats() {
+    if (this.useRedis && this.queue) {
+      try {
+        const [waiting, active, completed, failed] = await Promise.all([
+          this.queue.getWaitingCount(),
+          this.queue.getActiveCount(),
+          this.queue.getCompletedCount(),
+          this.queue.getFailedCount(),
+        ]);
+
+        return {
+          queueType: 'redis',
+          waiting,
+          active,
+          completed,
+          failed,
+          total: waiting + active + completed + failed,
+        };
+      } catch (error) {
+        logger.error('获取 Redis 队列状态失败:', error);
+      }
+    }
+
+    // 本地队列统计
+    return {
+      queueType: 'local',
+      waiting: this.localQueue.length,
+      active: this.currentConcurrent,
+      completed: 0, // 本地队列不保存历史
+      failed: 0,
+      total: this.localQueue.length + this.currentConcurrent,
+      maxConcurrent: this.maxConcurrent,
+    };
+  }
+
+  /**
+   * 清空队列
+   */
+  async clear() {
+    if (this.useRedis && this.queue) {
+      await this.queue.empty();
+      logger.info('🧹 Redis 队列已清空');
+    } else {
+      this.localQueue = [];
+      logger.info('🧹 本地队列已清空');
+    }
+  }
+
+  /**
+   * 暂停队列
+   */
+  async pause() {
+    if (this.useRedis && this.queue) {
+      await this.queue.pause();
+      logger.info('⏸️ Redis 队列已暂停');
+    } else {
+      this.processing = false;
+      logger.info('⏸️ 本地队列已暂停');
+    }
+  }
+
+  /**
+   * 恢复队列
+   */
+  async resume() {
+    if (this.useRedis && this.queue) {
+      await this.queue.resume();
+      logger.info('▶️ Redis 队列已恢复');
+    } else {
+      this.processing = true;
+      logger.info('▶️ 本地队列已恢复');
+    }
+  }
+
+  /**
+   * 关闭队列
+   */
+  async close() {
+    if (this.useRedis && this.queue) {
+      await this.queue.close();
+      if (this.redisClient) {
+        await this.redisClient.quit();
+      }
+      logger.info('👋 Redis 队列已关闭');
+    } else {
+      this.processing = false;
+      logger.info('👋 本地队列已关闭');
+    }
+  }
+}
+
+module.exports = new TaskQueue();

package/src/services/notification-limiter.js

@@ -0,0 +1,48 @@
+/**
+ * 通知限流器
+ * 防止短时间内通知过多骚扰用户
+ */
+class NotificationLimiter {
+  constructor(maxPerMinute = 5) {
+    this.queue = [];
+    this.maxPerMinute = maxPerMinute;
+  }
+
+  /**
+   * 检查是否允许发送通知
+   * @returns {boolean} 是否允许发送
+   */
+  canNotify() {
+    const now = Date.now();
+
+    // 清理 1 分钟前的记录
+    this.queue = this.queue.filter(timestamp => now - timestamp < 60000);
+
+    // 检查是否超过限制
+    if (this.queue.length >= this.maxPerMinute) {
+      return false;
+    }
+
+    // 记录当前通知
+    this.queue.push(now);
+    return true;
+  }
+
+  /**
+   * 重置限流器
+   */
+  reset() {
+    this.queue = [];
+  }
+
+  /**
+   * 获取当前队列长度
+   */
+  getQueueLength() {
+    const now = Date.now();
+    this.queue = this.queue.filter(timestamp => now - timestamp < 60000);
+    return this.queue.length;
+  }
+}
+
+module.exports = NotificationLimiter;