cfix 1.0.0

package/src/services/notification-service.js

@@ -0,0 +1,115 @@
+const SystemNotifier = require('./system-notifier');
+const NotificationLimiter = require('./notification-limiter');
+const { logger } = require('../logger');
+
+/**
+ * 统一通知服务
+ * 整合系统通知、WebSocket 和企业微信通知
+ */
+class NotificationService {
+  constructor(config, wechatNotifier, wsNotifier) {
+    this.systemNotifier = new SystemNotifier(config.systemNotification || {});
+    this.wechatNotifier = wechatNotifier;
+    this.wsNotifier = wsNotifier;
+    this.limiter = new NotificationLimiter(5); // 每分钟最多 5 条通知
+  }
+
+  /**
+   * 任务开始通知
+   */
+  async notifyTaskStart(taskId, projectName, requirement) {
+    // WebSocket 实时推送
+    if (this.wsNotifier) {
+      this.wsNotifier.notifyTaskStatus(taskId, 'running', {
+        message: '任务已开始',
+        requirement,
+        projectName,
+      });
+    }
+
+    // 企业微信通知
+    await this.wechatNotifier.notifyTaskStart(projectName, requirement);
+
+    // 系统 Toast 通知（限流）
+    if (this.limiter.canNotify()) {
+      this.systemNotifier.notifyTaskStart(projectName, requirement);
+    } else {
+      logger.warn('系统通知被限流，跳过发送', { taskId });
+    }
+  }
+
+  /**
+   * 任务完成通知
+   */
+  async notifyTaskComplete(taskId, result) {
+    const { projectName, branchName, changedFiles, summary } = result;
+
+    // WebSocket 推送
+    if (this.wsNotifier) {
+      this.wsNotifier.notifyTaskComplete(taskId, result);
+    }
+
+    // 企业微信通知
+    await this.wechatNotifier.notifyTaskSuccess(
+      projectName,
+      branchName,
+      changedFiles,
+      summary
+    );
+
+    // 系统 Toast 通知（限流）
+    if (this.limiter.canNotify()) {
+      this.systemNotifier.notifyTaskComplete(projectName, changedFiles);
+    } else {
+      logger.warn('系统通知被限流，跳过发送', { taskId });
+    }
+  }
+
+  /**
+   * 任务失败通知
+   */
+  async notifyTaskFailure(taskId, projectName, requirement, error) {
+    // WebSocket 推送
+    if (this.wsNotifier) {
+      this.wsNotifier.notifyTaskFailed(taskId, error);
+    }
+
+    // 企业微信通知
+    await this.wechatNotifier.notifyTaskFailure(
+      projectName,
+      requirement,
+      error.message
+    );
+
+    // 系统 Toast 通知（限流）
+    if (this.limiter.canNotify()) {
+      this.systemNotifier.notifyTaskFailure(projectName, error.message);
+    } else {
+      logger.warn('系统通知被限流，跳过发送', { taskId });
+    }
+  }
+
+  /**
+   * 等待确认通知
+   */
+  notifyWaitingApproval(taskId, changedFiles) {
+    // WebSocket 推送
+    if (this.wsNotifier) {
+      this.wsNotifier.notifyTaskProgress(
+        taskId,
+        'waiting_approval',
+        'AI 修复完成，等待开发者确认',
+        50
+      );
+    }
+
+    // 系统 Toast 通知（限流）
+    if (this.limiter.canNotify()) {
+      this.systemNotifier.notifyWaitingApproval(taskId, changedFiles);
+    } else {
+      logger.warn('系统通知被限流，跳过发送', { taskId });
+    }
+  }
+}
+
+module.exports = NotificationService;

package/src/services/system-notifier.js

@@ -0,0 +1,130 @@
+const notifier = require('node-notifier');
+const path = require('path');
+const fs = require('fs');
+const { logger } = require('../logger');
+
+/**
+ * 系统通知服务
+ * 使用 node-notifier 发送 Windows Toast 通知
+ */
+class SystemNotifier {
+  constructor(config = {}) {
+    this.enabled = config.enabled || false;
+    this.showOnStart = config.showOnTaskStart !== false;
+    this.showOnComplete = config.showOnTaskComplete !== false;
+    this.showOnFailure = config.showOnTaskFailure !== false;
+    this.showOnApproval = config.showOnApproval !== false;
+  }
+
+  /**
+   * 发送系统通知
+   * @param {Object} options - 通知选项
+   * @param {string} options.title - 通知标题
+   * @param {string} options.message - 通知内容
+   * @param {string} options.icon - 图标路径（可选）
+   * @param {boolean} options.sound - 是否播放声音
+   * @param {number} options.timeout - 显示时长（秒）
+   * @param {Function} options.onClick - 点击回调
+   */
+  notify(options) {
+    if (!this.enabled) {
+      logger.debug('系统通知已禁用，跳过发送');
+      return;
+    }
+
+    // 检查图标路径是否存在
+    const defaultIconPath = path.join(__dirname, '../assets/icon.png');
+    const iconPath = options.icon || (fs.existsSync(defaultIconPath) ? defaultIconPath : undefined);
+
+    notifier.notify(
+      {
+        title: options.title,
+        message: options.message,
+        icon: iconPath,
+        sound: options.sound || false,
+        wait: false,
+        timeout: options.timeout || 5,
+      },
+      (err, response, metadata) => {
+        if (err) {
+          logger.error('系统通知发送失败:', err.message);
+        } else {
+          logger.debug('系统通知已发送:', { title: options.title });
+        }
+      }
+    );
+
+    // 监听点击事件
+    if (options.onClick) {
+      notifier.on('click', options.onClick);
+    }
+  }
+
+  /**
+   * 任务开始通知
+   */
+  notifyTaskStart(projectName, requirement) {
+    if (!this.showOnStart) return;
+
+    const shortReq = requirement.length > 50
+      ? `${requirement.substring(0, 50)}...`
+      : requirement;
+
+    this.notify({
+      title: '🚀 修复任务已启动',
+      message: `项目: ${projectName}\n${shortReq}`,
+      sound: true,
+    });
+  }
+
+  /**
+   * 任务完成通知
+   */
+  notifyTaskComplete(projectName, changedFiles) {
+    if (!this.showOnComplete) return;
+
+    this.notify({
+      title: '✅ 修复任务完成',
+      message: `项目: ${projectName}\n修改文件: ${changedFiles.length} 个`,
+      sound: true,
+      onClick: () => {
+        logger.info('用户点击了任务完成通知');
+      },
+    });
+  }
+
+  /**
+   * 任务失败通知
+   */
+  notifyTaskFailure(projectName, error) {
+    if (!this.showOnFailure) return;
+
+    const shortError = error.length > 50
+      ? `${error.substring(0, 50)}...`
+      : error;
+
+    this.notify({
+      title: '❌ 修复任务失败',
+      message: `项目: ${projectName}\n${shortError}`,
+      sound: true,
+    });
+  }
+
+  /**
+   * 等待确认通知
+   */
+  notifyWaitingApproval(taskId, changedFiles) {
+    if (!this.showOnApproval) return;
+
+    this.notify({
+      title: '⏸️ 等待开发者确认',
+      message: `修改了 ${changedFiles.length} 个文件\n点击查看详情`,
+      sound: true,
+      onClick: () => {
+        logger.info(`用户点击了等待确认通知: ${taskId}`);
+      },
+    });
+  }
+}
+
+module.exports = SystemNotifier;

package/src/task-manager.js

@@ -0,0 +1,289 @@
+const fs = require('fs');
+const path = require('path');
+const { logger } = require('./logger');
+
+/**
+ * 任务管理器 - 管理异步修复任务
+ * 支持任务持久化到本地文件
+ */
+class TaskManager {
+  constructor() {
+    this.tasks = new Map(); // taskId -> task info
+    this.runningProcesses = new Map(); // taskId -> childProcess (用于任务取消)
+    this.storageFile = path.join(__dirname, '../data/tasks.json');
+    this.loadTasks(); // 启动时加载历史任务
+  }
+
+  /**
+   * 从文件加载任务
+   */
+  loadTasks() {
+    try {
+      // 确保数据目录存在
+      const dataDir = path.dirname(this.storageFile);
+      if (!fs.existsSync(dataDir)) {
+        fs.mkdirSync(dataDir, { recursive: true });
+      }
+
+      // 加载任务文件
+      if (fs.existsSync(this.storageFile)) {
+        const data = fs.readFileSync(this.storageFile, 'utf-8');
+        const tasksArray = JSON.parse(data);
+
+        // 转换为 Map
+        this.tasks = new Map(tasksArray.map(task => [task.id, task]));
+
+        logger.info(`📂 已加载 ${this.tasks.size} 条历史任务记录`);
+      } else {
+        logger.info('📂 未找到历史任务记录，将创建新文件');
+      }
+    } catch (error) {
+      logger.error(`❌ 加载任务记录失败: ${error.message}`);
+      this.tasks = new Map(); // 加载失败时使用空 Map
+    }
+  }
+
+  /**
+   * 保存任务到文件
+   */
+  saveTasks() {
+    try {
+      // 确保数据目录存在
+      const dataDir = path.dirname(this.storageFile);
+      if (!fs.existsSync(dataDir)) {
+        fs.mkdirSync(dataDir, { recursive: true });
+      }
+
+      // 转换 Map 为数组并保存
+      const tasksArray = Array.from(this.tasks.values());
+      fs.writeFileSync(this.storageFile, JSON.stringify(tasksArray, null, 2), 'utf-8');
+
+      logger.debug(`💾 任务记录已保存 (共 ${this.tasks.size} 条)`);
+    } catch (error) {
+      logger.error(`❌ 保存任务记录失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 创建新任务
+   */
+  createTask(requirement, projectPath, options = {}) {
+    const taskId = `task-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+
+    const task = {
+      id: taskId,
+      status: 'pending', // pending, running, completed, failed
+      requirement,
+      projectPath: projectPath || options.projectPath,
+      repoUrl: options.repoUrl || null,
+      // 展开 options 中的参数到任务对象
+      runTests: options.runTests || false,
+      autoPush: options.autoPush !== undefined ? options.autoPush : true,
+      aiEngine: options.aiEngine || null,
+      baseBranch: options.baseBranch || null,
+      createNewBranch: options.createNewBranch !== undefined ? options.createNewBranch : true,  // 新增：是否创建新分支
+      username: options.username || 'system',  // 新增：用户名
+      mergeToAlpha: options.mergeToAlpha || false,
+      mergeToBeta: options.mergeToBeta || false,
+      mergeToMaster: options.mergeToMaster || false,
+      createdAt: new Date().toISOString(),
+      startedAt: null,
+      completedAt: null,
+      duration: null,  // 执行耗时
+      result: null,
+      error: null,
+      progress: {
+        step: 'created',
+        message: '任务已创建',
+      },
+    };
+
+    this.tasks.set(taskId, task);
+    this.saveTasks(); // 立即保存
+    return taskId;
+  }
+
+  /**
+   * 获取任务状态
+   */
+  getTask(taskId) {
+    return this.tasks.get(taskId);
+  }
+
+  /**
+   * 更新任务状态
+   */
+  updateTask(taskId, updates) {
+    const task = this.tasks.get(taskId);
+    if (task) {
+      Object.assign(task, updates);
+      this.tasks.set(taskId, task);
+      this.saveTasks(); // 每次更新都保存
+    }
+  }
+
+  /**
+   * 更新任务进度
+   */
+  updateProgress(taskId, step, message) {
+    const task = this.tasks.get(taskId);
+    if (task) {
+      task.progress = { step, message };
+      this.tasks.set(taskId, task);
+      // 进度更新频繁，不立即保存，只在状态变更时保存
+    }
+  }
+
+  /**
+   * 标记任务开始
+   */
+  startTask(taskId) {
+    this.updateTask(taskId, {
+      status: 'running',
+      startedAt: new Date().toISOString(),
+    });
+  }
+
+  /**
+   * 标记任务完成
+   */
+  completeTask(taskId, result) {
+    const task = this.tasks.get(taskId);
+    if (!task) return;
+
+    const completedAt = new Date().toISOString();
+    let duration = null;
+
+    // 计算执行耗时
+    if (task.startedAt) {
+      const startTime = new Date(task.startedAt).getTime();
+      const endTime = new Date(completedAt).getTime();
+      duration = ((endTime - startTime) / 1000).toFixed(2) + 's';
+    }
+
+    this.updateTask(taskId, {
+      status: 'completed',
+      completedAt,
+      duration,
+      result,
+    });
+  }
+
+  /**
+   * 标记任务失败
+   */
+  failTask(taskId, error) {
+    const task = this.tasks.get(taskId);
+    if (!task) return;
+
+    const completedAt = new Date().toISOString();
+    let duration = null;
+
+    // 计算执行耗时
+    if (task.startedAt) {
+      const startTime = new Date(task.startedAt).getTime();
+      const endTime = new Date(completedAt).getTime();
+      duration = ((endTime - startTime) / 1000).toFixed(2) + 's';
+    }
+
+    this.updateTask(taskId, {
+      status: 'failed',
+      completedAt,
+      duration,
+      error: error.message || String(error),
+    });
+  }
+
+  /**
+   * 清理旧任务（保留最近 100 个）
+   */
+  cleanup() {
+    if (this.tasks.size > 100) {
+      const sortedTasks = Array.from(this.tasks.entries())
+        .sort((a, b) => new Date(b[1].createdAt) - new Date(a[1].createdAt));
+
+      this.tasks.clear();
+      sortedTasks.slice(0, 100).forEach(([id, task]) => {
+        this.tasks.set(id, task);
+      });
+
+      this.saveTasks(); // 清理后保存
+      logger.info(`🧹 已清理旧任务，保留最近 100 条记录`);
+    }
+  }
+
+  /**
+   * 获取所有任务列表
+   */
+  getAllTasks(limit = 20) {
+    const sortedTasks = Array.from(this.tasks.values())
+      .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
+      .slice(0, limit);
+
+    return sortedTasks;
+  }
+
+  /**
+   * 注册运行中的进程
+   * @param {string} taskId - 任务ID
+   * @param {Object} processInfo - 进程信息（包含取消函数）
+   */
+  registerProcess(taskId, processInfo) {
+    this.runningProcesses.set(taskId, processInfo);
+    logger.debug(`注册任务进程: ${taskId}`);
+  }
+
+  /**
+   * 注销运行中的进程
+   * @param {string} taskId - 任务ID
+   */
+  unregisterProcess(taskId) {
+    this.runningProcesses.delete(taskId);
+    logger.debug(`注销任务进程: ${taskId}`);
+  }
+
+  /**
+   * 取消任务
+   * @param {string} taskId - 任务ID
+   * @returns {boolean} 是否成功取消
+   */
+  cancelTask(taskId) {
+    const task = this.tasks.get(taskId);
+
+    if (!task) {
+      throw new Error('任务不存在');
+    }
+
+    if (task.status !== 'running' && task.status !== 'pending') {
+      throw new Error(`任务状态为 ${task.status}，无法取消`);
+    }
+
+    const processInfo = this.runningProcesses.get(taskId);
+
+    if (processInfo && processInfo.cancel) {
+      try {
+        // 调用取消函数
+        processInfo.cancel();
+        logger.info(`🛑 任务 ${taskId} 已请求取消`);
+      } catch (error) {
+        logger.error(`取消任务失败: ${error.message}`);
+      }
+    }
+
+    // 更新任务状态
+    this.updateTask(taskId, {
+      status: 'cancelled',
+      completedAt: new Date().toISOString(),
+      error: '任务已被用户取消',
+    });
+
+    // 注销进程
+    this.unregisterProcess(taskId);
+
+    logger.info(`✅ 任务 ${taskId} 已取消`);
+
+    return true;
+  }
+}
+
+module.exports = new TaskManager();

package/src/utils/exec.js

@@ -0,0 +1,87 @@
+const { execSync, spawn } = require('child_process');
+const { logger } = require('../logger');
+
+/**
+ * 统一的进程执行工具类
+ * 在 Windows 上隐藏 CMD 窗口，同时保持日志输出正常
+ */
+class ExecUtil {
+  /**
+   * 同步执行命令（隐藏窗口）
+   * @param {string} command - 要执行的命令
+   * @param {Object} options - execSync 选项
+   * @returns {string} 命令输出
+   */
+  static execSync(command, options = {}) {
+    const mergedOptions = {
+      // 🔑 关键：在 Windows 上隐藏 CMD 窗口
+      windowsHide: true,
+
+      // 默认编码
+      encoding: 'utf-8',
+
+      // 默认不显示实时输出（通过 logger 记录）
+      stdio: 'pipe',
+
+      // 合并用户自定义选项
+      ...options,
+
+      // 确保 windowsHide 不会被覆盖
+      windowsHide: true,
+    };
+
+    try {
+      const output = execSync(command, mergedOptions);
+
+      // 如果需要，可以在这里记录命令执行日志
+      if (options.debug) {
+        logger.debug(`[Exec] 命令执行成功: ${command.substring(0, 100)}...`);
+      }
+
+      return output;
+    } catch (error) {
+      // 错误日志由调用方处理
+      throw error;
+    }
+  }
+
+  /**
+   * 异步执行命令（隐藏窗口）
+   * @param {string} command - 要执行的命令
+   * @param {Array} args - 命令参数数组
+   * @param {Object} options - spawn 选项
+   * @returns {ChildProcess} 子进程实例
+   */
+  static spawn(command, args = [], options = {}) {
+    const mergedOptions = {
+      // 🔑 关键：在 Windows 上隐藏 CMD 窗口
+      windowsHide: true,
+
+      // 默认的 stdio 配置
+      stdio: ['ignore', 'pipe', 'pipe'],
+
+      // 合并用户自定义选项
+      ...options,
+
+      // 确保 windowsHide 不会被覆盖
+      windowsHide: true,
+    };
+
+    return spawn(command, args, mergedOptions);
+  }
+
+  /**
+   * 使用 shell 模式执行命令（隐藏窗口）
+   * @param {string} command - 完整的 shell 命令字符串
+   * @param {Object} options - spawn 选项
+   * @returns {ChildProcess} 子进程实例
+   */
+  static spawnShell(command, options = {}) {
+    return this.spawn(command, [], {
+      ...options,
+      shell: true,
+    });
+  }
+}
+
+module.exports = ExecUtil;